Python并发编程之从性能角度来初探并发编程（一）

本文目录

---

• 并发编程的基本概念

• 单线程VS多线程VS多进程

• 性能对比成果总结

前言

做为进阶系列的一个分支「并发编程」，我以为这是每一个程序员都应该会的。

并发编程 这个系列，我准备了将近一个星期，从知识点梳理，到思考要举哪些例子才能更加让人容易吃透这些知识点。但愿呈现出来的效果然能如想象中的那样，对小白也同样的友好。

昨天大体整理了下，这个系列我大概会讲以下内容（后期可能调整）：

对于并发编程，Python的实现，总结了一下，大体有以下三种方法：

• 多线程

• 多进程

• 协程（生成器）

在以后的章节里，将陆陆续续地给你们介绍到这三个知识点。

. 并发编程的基本概念

在开始讲解理论知识以前，先过一下几个基本概念。虽然咱是进阶教程，但我也但愿写得更小白，更通俗易懂。

串行：一我的在同一时间段只能干一件事，譬如吃完饭才能看电视；
并行：一我的在同一时间段能够干多件事，譬如能够边吃饭边看电视；

在Python中，多线程 和 协程 虽然是严格上来讲是串行，但却比通常的串行程序执行效率高得很。
通常的串行程序，在程序阻塞的时候，只能干等着，不能去作其余事。就好像，电视上播完正剧，进入广告时间，咱们却不能去趁广告时间是吃个饭。对于程序来讲，这样作显然是效率极低的，是不合理的。

固然，学完这个课程后，咱们就懂得，利用广告时间去作其余事，灵活安排时间。这也是咱们多线程和协程 要帮咱们要完成的事情，内部合理调度任务，使得程序效率最大化。

虽然 多线程 和 协程 已经至关智能了。但仍是不够高效，最高效的应该是一心多用，边看电视边吃饭边聊天。这就是咱们的 多进程才能作的事了。

为了更帮助你们更加直观的理解，在网上找到两张图，来生动形象的解释了多线程和多进程的区别。（侵删）

• 多线程，交替执行，另外一种意义上的串行。

• 多进程，并行执行，真正意义上的并发。

. 单线程VS多线程VS多进程

文字老是苍白无力的，千言万语不如几行代码来得孔武有力。

接下来，让咱们一块儿用代码来测试一下，单线程、多线程、多进程到底性能差多少呢？

首先，准备环境，个人实验环境配置以下：

操做系统	CPU核数	内存(G)	硬盘
CentOS 7.2	24核	32	机械硬盘

注意
如下代码，若要理解，对小白有以下知识点要求:

1. 装饰器的运用

2. 多线程的基本使用

3. 多进程的基本使用

固然，看不懂也不要紧，主要最后的结论，能让你们对单线程、多线程、多进程在实现效果上有个大致清晰的认识，达到这个效果，本文的使命也就完成了，等到最后，学完整个系列，不妨再回头来理解也许会有更深入的理解。

下面咱们来看看，单线程，多线程和多进程，在运行中究竟孰强孰弱。

开始对比以前，首先定义四种类型的场景

• CPU计算密集型

• 磁盘IO密集型

• 网络IO密集型

• 【模拟】IO密集型

为何是这几种场景，这和多线程 多进程的适用场景有关。结论里，我再说明。

 1# CPU计算密集型
 2def count(x=1, y=1):
 3    # 使程序完成150万计算
 4    c = 0
 5    while c < 500000:
 6        c += 1
 7        x += x
 8        y += y
 9
10
11# 磁盘读写IO密集型
12def io_disk():
13    with open("file.txt", "w") as f:
14        for x in range(5000000):
15            f.write("python-learning\n")
16
17
18# 网络IO密集型
19header = {
20    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36'}
21url = "https://www.tieba.com/"
22
23def io_request():
24    try:
25        webPage = requests.get(url, headers=header)
26        html = webPage.text
27        return
28    except Exception as e:
29        return {"error": e}
30
31
32# 【模拟】IO密集型
33def io_simulation():
34    time.sleep(2)

比拼的指标，咱们用时间来考量。时间耗费得越少，说明效率越高。

为了方便，使得代码看起来，更加简洁，我这里先定义是一个简单的时间计时器 的装饰器。
若是你对装饰器还不是很了解，也不要紧，你只要知道它是用于 计算函数运行时间的东西就能够了。

 1def timer(mode):
 2    def wrapper(func):
 3        def deco(*args, **kw):
 4            type = kw.setdefault('type', None)
 5            t1=time.time()
 6            func(*args, **kw)
 7            t2=time.time()
 8            cost_time = t2-t1
 9            print("{}-{}花费时间：{}秒".format(mode, type,cost_time))
10        return deco
11    return wrapper

第一步，先来看看单线程的

 1@timer("【单线程】")
 2def single_thread(func, type=""):
 3    for i in range(10):
 4              func()
 5
 6# 单线程
 7single_thread(count, type="CPU计算密集型")
 8single_thread(io_disk, type="磁盘IO密集型")
 9single_thread(io_request,type="网络IO密集型")
10single_thread(io_simulation,type="模拟IO密集型")

看看结果

1【单线程】-CPU计算密集型花费时间：83.42633867263794秒
2【单线程】-磁盘IO密集型花费时间：15.641993284225464秒
3【单线程】-网络IO密集型花费时间：1.1397218704223633秒
4【单线程】-模拟IO密集型花费时间：20.020972728729248秒

第二步，再来看看多线程的

 1@timer("【多线程】")
 2def multi_thread(func, type=""):
 3    thread_list = []
 4    for i in range(10):
 5        t=Thread(target=func, args=())
 6        thread_list.append(t)
 7        t.start()
 8    e = len(thread_list)
 9
10    while True:
11        for th in thread_list:
12            if not th.is_alive():
13                e -= 1
14        if e <= 0:
15            break
16
17# 多线程
18multi_thread(count, type="CPU计算密集型")
19multi_thread(io_disk, type="磁盘IO密集型")
20multi_thread(io_request, type="网络IO密集型")
21multi_thread(io_simulation, type="模拟IO密集型")

看看结果

1【多线程】-CPU计算密集型花费时间：93.82986998558044秒
2【多线程】-磁盘IO密集型花费时间：13.270896911621094秒
3【多线程】-网络IO密集型花费时间：0.1828296184539795秒
4【多线程】-模拟IO密集型花费时间：2.0288875102996826秒

第三步，最后来看看多进程

 1@timer("【多进程】")
 2def multi_process(func, type=""):
 3    process_list = []
 4    for x in range(10):
 5        p = Process(target=func, args=())
 6        process_list.append(p)
 7        p.start()
 8    e = process_list.__len__()
 9
10    while True:
11        for pr in process_list:
12            if not pr.is_alive():
13                e -= 1
14        if e <= 0:
15            break
16
17# 多进程
18multi_process(count, type="CPU计算密集型")
19multi_process(io_disk, type="磁盘IO密集型")
20multi_process(io_request, type="网络IO密集型")
21multi_process(io_simulation, type="模拟IO密集型")

看看结果

1【多进程】-CPU计算密集型花费时间：9.082211017608643秒
2【多进程】-磁盘IO密集型花费时间：1.287339448928833秒
3【多进程】-网络IO密集型花费时间：0.13074755668640137秒
4【多进程】-模拟IO密集型花费时间：2.0076842308044434秒

. 性能对比成果总结

将结果汇总一下，制成表格。

种类	CPU 计算密集型	磁盘 IO密集型	网络 IO密集型	模拟 IO密集型
单线程	83.42	15.64	1.13	20.02
多线程	93.82	13.27	0.18	2.02
多进程	9.08	1.28	0.13	2.01

咱们来分析下这个表格。

首先是CPU密集型，多线程以对比单线程，不只没有优点，显然还因为要不断的加锁释放GIL全局锁，切换线程而耗费大量时间，效率低下，而多进程，因为是多个CPU同时进行计算工做，至关于十我的作一我的的做业，显然效率是成倍增加的。

而后是IO密集型，IO密集型能够是磁盘IO，网络IO，数据库IO等，都属于同一类，计算量很小，主要是IO等待时间的浪费。经过观察，能够发现，咱们磁盘IO，网络IO的数据，多线程对比单线程也没体现出很大的优点来。这是因为咱们程序的的IO任务不够繁重，因此优点不够明显。

因此我还加了一个「模拟IO密集型」，用sleep来模拟IO等待时间，就是为了体现出多线程的优点，也能让你们更加直观的理解多线程的工做过程。单线程须要每一个线程都要sleep(2)，10个线程就是20s，而多线程，在sleep(2)的时候，会切换到其余线程，使得10个线程同时sleep(2)，最终10个线程也就只有2s.

能够得出如下几点结论

• 单线程老是最慢的，多进程老是最快的。

• 多线程适合在IO密集场景下使用，譬如爬虫，网站开发等

• 多进程适合在对CPU计算运算要求较高的场景下使用，譬如大数据分析，机器学习等

• 多进程虽然老是最快的，可是不必定是最优的选择，由于它须要CPU资源支持下才能体现优点