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

时间  2019-11-13
标签 python3 python multiprocessing threading gevent 性能 对比 进程 线程 栏目 Python 繁體版
原文   原文链接

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

 

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

 

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

运行结果以下：

 

 

        从上图能够看出，python3自带的urllib.request效率仍是不如开源的requests，multiprocessing进程池效率明显提高，但还低于本身封装的线程池，有一部分缘由是建立、调度进程的开销比建立线程高（测试程序中我把建立的代价也包括在里面）。网络

        下面是gevent的测试代码：app

 

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

运行结果以下：

 

        从上图能够看到，对于I/O密集型任务，gevent仍是能对性能作很大提高的，因为协程的建立、调度开销都比线程小的多，因此能够看到不论使用gevent的Spawn模式仍是Pool模式，性能差距不大。socket

        由于在gevent中须要使用monkey补丁，会提升gevent的性能，但会影响multiprocessing的运行，若是要同时使用，须要以下代码：post

 

[python]  view plain  copy
 
  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测试

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程