python3下multiprocessing、threading和gevent性能对比----暨进程池、线程池和协程池性能对比

python3下multiprocessing、threading和gevent性能对比----暨进程池、线程池和协程池性能对比

 

• 标签：
• python3 /
• 线程池 /
• multiprocessing /
• gevent /
• threading

• 30004

目前计算机程序一般会遇到两类I/O：硬盘I/O和网络I/O。我就针对网络I/O的场景分析下python3下进程、线程、协程效率的对比。进程采用multiprocessing.Pool进程池，线程是自己封装的进程池，协程采用gevent的库。用python3自带的urlllib.request和开源的requests做对比。代码如下：

1. import urllib.request
2. import requests
3. import time
4. import multiprocessing
5. import threading
6. import queue
7. def startTimer():
8. return time.time()
9. def ticT(startTime):
10. useTime = time.time() - startTime
11. return round(useTime, 3)
12. #def tic(startTime, name):
13. #    useTime = time.time() - startTime
14. #    print('[%s] use time: %1.3f' % (name, useTime))
15. def download_urllib(url):
16. req = urllib.request.Request(url,
17. headers={'user-agent': 'Mozilla/5.0'})
18. res = urllib.request.urlopen(req)
19. data = res.read()
20. try:
21. data = data.decode('gbk')
22. except UnicodeDecodeError:
23. data = data.decode('utf8', 'ignore')
24. return res.status, data
25. def download_requests(url):
26. req = requests.get(url,
27. headers={'user-agent': 'Mozilla/5.0'})
28. return req.status_code, req.text
29. class threadPoolManager:
30. def __init__(self,urls, workNum=10000,threadNum=20):
31. self.workQueue=queue.Queue()
32. self.threadPool=[]
33. self.__initWorkQueue(urls)
34. self.__initThreadPool(threadNum)
35. def __initWorkQueue(self,urls):
36. for i in urls:
37. self.workQueue.put((download_requests,i))
38. def __initThreadPool(self,threadNum):
39. for i in range(threadNum):
40. self.threadPool.append(work(self.workQueue))
41. def waitAllComplete(self):
42. for i in self.threadPool:
43. if i.isAlive():
44. i.join()
45. class work(threading.Thread):
46. def __init__(self,workQueue):
47. threading.Thread.__init__(self)
48. self.workQueue=workQueue
49. self.start()
50. def run(self):
51. while True:
52. if self.workQueue.qsize():
53. do,args=self.workQueue.get(block=False)
54. do(args)
55. self.workQueue.task_done()
56. else:
57. break
58. urls = ['http://www.ustchacker.com'] * 10
59. urllibL = []
60. requestsL = []
61. multiPool = []
62. threadPool = []
63. N = 20
64. PoolNum = 100
65. for i in range(N):
66. print('start %d try' % i)
67. urllibT = startTimer()
68. jobs = [download_urllib(url) for url in urls]
69. #for status, data in jobs:
70. #    print(status, data[:10])
71. #tic(urllibT, 'urllib.request')
72. urllibL.append(ticT(urllibT))
73. print('1')
74. requestsT = startTimer()
75. jobs = [download_requests(url) for url in urls]
76. #for status, data in jobs:
77. #    print(status, data[:10])
78. #tic(requestsT, 'requests')
79. requestsL.append(ticT(requestsT))
80. print('2')
81. requestsT = startTimer()
82. pool = multiprocessing.Pool(PoolNum)
83. data = pool.map(download_requests, urls)
84. pool.close()
85. pool.join()
86. multiPool.append(ticT(requestsT))
87. print('3')
88. requestsT = startTimer()
89. pool = threadPoolManager(urls, threadNum=PoolNum)
90. pool.waitAllComplete()
91. threadPool.append(ticT(requestsT))
92. print('4')
93. import matplotlib.pyplot as plt
94. x = list(range(1, N+1))
95. plt.plot(x, urllibL, label='urllib')
96. plt.plot(x, requestsL, label='requests')
97. plt.plot(x, multiPool, label='requests MultiPool')
98. plt.plot(x, threadPool, label='requests threadPool')
99. plt.xlabel('test number')
100. plt.ylabel('time(s)')
101. plt.legend()
102. plt.show()

运行结果如下：

从上图可以看出，python3自带的urllib.request效率还是不如开源的requests，multiprocessing进程池效率明显提升，但还低于自己封装的线程池，有一部分原因是创建、调度进程的开销比创建线程高（测试程序中我把创建的代价也包括在里面）。

下面是gevent的测试代码：

1. import urllib.request
2. import requests
3. import time
4. import gevent.pool
5. import gevent.monkey
6. gevent.monkey.patch_all()
7. def startTimer():
8. return time.time()
9. def ticT(startTime):
10. useTime = time.time() - startTime
11. return round(useTime, 3)
12. #def tic(startTime, name):
13. #    useTime = time.time() - startTime
14. #    print('[%s] use time: %1.3f' % (name, useTime))
15. def download_urllib(url):
16. req = urllib.request.Request(url,
17. headers={'user-agent': 'Mozilla/5.0'})
18. res = urllib.request.urlopen(req)
19. data = res.read()
20. try:
21. data = data.decode('gbk')
22. except UnicodeDecodeError:
23. data = data.decode('utf8', 'ignore')
24. return res.status, data
25. def download_requests(url):
26. req = requests.get(url,
27. headers={'user-agent': 'Mozilla/5.0'})
28. return req.status_code, req.text
29. urls = ['http://www.ustchacker.com'] * 10
30. urllibL = []
31. requestsL = []
32. reqPool = []
33. reqSpawn = []
34. N = 20
35. PoolNum = 100
36. for i in range(N):
37. print('start %d try' % i)
38. urllibT = startTimer()
39. jobs = [download_urllib(url) for url in urls]
40. #for status, data in jobs:
41. #    print(status, data[:10])
42. #tic(urllibT, 'urllib.request')
43. urllibL.append(ticT(urllibT))
44. print('1')
45. requestsT = startTimer()
46. jobs = [download_requests(url) for url in urls]
47. #for status, data in jobs:
48. #    print(status, data[:10])
49. #tic(requestsT, 'requests')
50. requestsL.append(ticT(requestsT))
51. print('2')
52. requestsT = startTimer()
53. pool = gevent.pool.Pool(PoolNum)
54. data = pool.map(download_requests, urls)
55. #for status, text in data:
56. #    print(status, text[:10])
57. #tic(requestsT, 'requests with gevent.pool')
58. reqPool.append(ticT(requestsT))
59. print('3')
60. requestsT = startTimer()
61. jobs = [gevent.spawn(download_requests, url) for url in urls]
62. gevent.joinall(jobs)
63. #for i in jobs:
64. #    print(i.value[0], i.value[1][:10])
65. #tic(requestsT, 'requests with gevent.spawn')
66. reqSpawn.append(ticT(requestsT))
67. print('4')
68. import matplotlib.pyplot as plt
69. x = list(range(1, N+1))
70. plt.plot(x, urllibL, label='urllib')
71. plt.plot(x, requestsL, label='requests')
72. plt.plot(x, reqPool, label='requests geventPool')
73. plt.plot(x, reqSpawn, label='requests Spawn')
74. plt.xlabel('test number')
75. plt.ylabel('time(s)')
76. plt.legend()
77. plt.show()

运行结果如下：

从上图可以看到，对于I/O密集型任务，gevent还是能对性能做很大提升的，由于协程的创建、调度开销都比线程小的多，所以可以看到不论使用gevent的Spawn模式还是Pool模式，性能差距不大。

因为在gevent中需要使用monkey补丁，会提高gevent的性能，但会影响multiprocessing的运行，如果要同时使用，需要如下代码：

1. gevent.monkey.patch_all(thread=False, socket=False, select=False)

可是这样就不能充分发挥gevent的优势，所以不能把multiprocessing Pool、threading Pool、gevent Pool在一个程序中对比。不过比较两图可以得出结论，线程池和gevent的性能最优的，其次是进程池。附带得出个结论，requests库比urllib.request库性能要好一些哈:-)

转载请注明：转自http://blog.csdn.net/littlethunder/article/details/40983031