Python 进程线程协程(4)--线程池

你勤奋充电努力工作保持身材，对人微笑这些都不是为了取悦他人，而是为了扮靓自己照亮自己的心，告诉自己我是一股独立向上的力量。

在Python中还有一个线程池的概念，它也有并发处理能力，在一定程度上能提高系统运行效率；

线程的生命周期可以分为5个状态：创建、就绪、运行、阻塞和终止。自线程创建到终止，线程便不断在运行、创建和销毁这3个状态。一个线程的运行时间可由此可以分为3部分：线程的启动时间、线程体的运行时间和线程的销毁时间。在多线程处理的情景中，如果线程不能被重用，就意味着每次创建都需要经过启动、销毁和运行3个过程。这必然会增加系统相应的时间，降低了效率。看看之前介绍线程的博文的例子中（点击此处可以阅读），有多少个任务，就创建多少个线程，但是由于Python特有的GIL限制，它并不是真正意义上的多线程，反而会因为频繁的切换任务等开销而降低了性能( 点击此处可以了解Python的GIL)。这种情况下可以使用线程池提高运行效率。

线程池的基本原理如下图，它是通过将事先创建多个能够执行任务的线程放入池中，所需要执行的任务通常要被安排在队列任务中。一般情况下，需要处理的任务比线程数目要多，线程执行完当前任务后，会从队列中取下一个任务，知道所有的任务完成。

由于线程预先被创建并放入线程池中，同时处理完当前任务之后并不销毁而是被安排处理下一个任务，因此能够避免多次创建线程，从而节省线程创建和销毁的开销，能带来更好的性能和系统稳定性。所以，说白了，Python的线程池也没有利用到多核或者多CPU的优势，只是跟普通的多线程相比，它不用去多次创建线程，节省了线程创建和销毁的时间，从而提高了性能。

Python中线程池技术适合处理突发性大量请求或者需要大量线程来完成任务、但每个任务实际处理时间较短的场景，它能有效的避免由于系统创建线程过多而导致性能负荷过大、响应过慢等问题。下面介绍几种利用线程池的方法。

自定义线程池模式

我们可以利用Queue模块和threading模块来实现线程池。Queue用来创建任务队列，threading用来创建一个线程池子。

看下面例子

import Queue,threading

class Worker(threading.Thread):
    """
    定义一个能够处理任务的线程类，属于自定义线程类，自定义线程类就需要定义run()函数
    """

    def __init__(self,workqueue,resultqueue,**kwargs):
        threading.Thread.__init__(self,**kwargs)
        self.workqueue = workqueue#存放任务的队列,任务一般都是函数
        self.resultqueue = resultqueue#存放结果的队列

    def run(self):
        while True:
            try:
                #从任务队列中取出一个任务，block设置为False表示如果队列空了，就会抛出异常
                callable,args,kwargs = self.workqueue.get(block=False)
                res = callable(*args,**kwargs)
                self.resultqueue.put(res)#将任务的结果存放到结果队列中
            except Queue.Empty:#抛出空队列异常
                break

class WorkerManger(object):
    """
    定义一个线程池的类
    """
    def __init__(self,num=10):#默认这个池子里有10个线程
        self.workqueue = Queue.Queue()#任务队列，
        self.resultqueue = Queue.Queue()#存放任务结果的队列
        self.workers = []#所有的线程都存放在这个列表中
        self._recruitthreads(num)#创建一系列线程的函数
    def _recruitthreads(self,num):
        """
        创建线程
        """
        for i in xrange(num):
            worker = Worker(self.workqueue,self.resultqueue)
            self.workers.append(worker)

    def start(self):
        """
        启动线程池中每个线程
        """
        for work in self.workers:
            work.start()

    def wait_for_complete(self):
        """
        等待至任务队列中所有任务完成
        """
        while len(self.workers):
            worker = self.workers.pop()
            worker.join()
            if worker.isAlive() and not self.workqueue.empty():
                self.workers.append(worker)

    def add_job(self,callable,*args,**kwargs):
        """
        往任务队列中添加任务
        """
        self.workqueue.put((callable,args,kwargs))


    def get_result(self,*args,**kwargs):
        """
        获取结果队列
        """
        return self.resultqueue.get(*args,**kwargs)
        
    def add_result(self,result):
        self.resultqueue.put(result)

上面定义了一个线程池，它的初始化函数init()定义了一些存放相关数据的属性，这在Python的一些内部模块的类的定义中很常见，所有有时候多看看源码其实挺好的，学习大神的编程习惯和编程思想。

另外还要提到一点，Queue模块中的队列，不仅可以存放数据（指字符串，数值，列表，字典等等），还可以存放函数的（也就是任务），上面的代码中，callable是一个函数，当用put()将一个函数添加到队列时，put()接受的参数有函数对象以及该函数的相关参数，而且要是一个整体，所以就有了上面代码中的self.workqueue.put((callable,args,kwargs))。同理，当从这种存放函数的队列中取出数据，它返回的就是一个函数对象包括它的相关参数，有兴趣的可以打印出上面代码中run()里的callable,args,kwargs。

下面就简单的举个小例子吧。

import urllib2,datetime
def open_url(url):
    try:
        res = urllib2.urlopen(url).getcode()
    except urllib2.HTTPError, e:
        res = e.code
    #print res
    res = str(res)
    with open('/home/liulonghua/无标题文档','wr') as f:
        f.write(res)
    return res
if __name__ == "__main__":
    urls = [
        'http://www.python.org',
        'http://www.python.org/about/',
        'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
        'http://www.python.org/doc/',
        'http://www.python.org/download/',
        'http://www.python.org/getit/',
        'http://www.python.org/community/',
        'https://wiki.python.org/moin/',
        'http://planet.python.org/',
        'https://wiki.python.org/moin/LocalUserGroups',
        'http://www.python.org/psf/',
        'http://docs.python.org/devguide/',
        'http://www.python.org/community/awards/'
    ]
    t1 = datetime.datetime.now()
    w = WorkerManger(2)
    for url in urls:
        w.add_job(open_url,url)
    w.start()
    w.wait_for_complete()
    t2 = datetime.datetime.now()
    print t2 - t1

最后结果如下：

如果把上面代码改成用多线程而不是用线程池，会是怎样的呢？

代码如下：

if __name__ == "__main__":
    urls = [
        'http://www.python.org',
        'http://www.python.org/about/',
        'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
        'http://www.python.org/doc/',
        'http://www.python.org/download/',
        'http://www.python.org/getit/',
        'http://www.python.org/community/',
        'https://wiki.python.org/moin/',
        'http://planet.python.org/',
        'https://wiki.python.org/moin/LocalUserGroups',
        'http://www.python.org/psf/',
        'http://docs.python.org/devguide/',
        'http://www.python.org/community/awards/'
    ]
    t1 = datetime.datetime.now()
    for url in urls:
        t = threading.Thread(target=open_url,args=(url,))
        t.start()
        t.join()
    t2 = datetime.datetime.now()
    print t2-t1

运行效率的差异还是很大的，有兴趣的可以动手试试。

使用现成的线程池模块

下载安装也很简单，用pip工具

1	sudo pip install threadpool

注意：这里要提到一点，我就陷入这个坑，还好没有花多长时间就解决了。由于我的电脑里有python2.7.12,python3.5,还有一个PyPy5.4.1，上面的指令竟然将threadpool包安装到了PyPy目录下了，所以在python2.7.12里，我import threadpool，它一直报错，如果你的系统里有多个Python版本，又没有用virtualenvs虚拟环境工具，很容易造成这种混乱，虽然我安装了virtualenvs，但在自己的电脑上很少用，这里的解决方法是：

1	sudo python -m pip install threadpool

以区分PyPy，同理如果是在PyPy环境下安装第三方包的话，用sudo pypy -m pip install packagename,这个在之前的博文中也有介绍，感兴趣的可以点此

该模块主要的类和方法：

threadpool.ThreadPool:线程池类，主要是用来分派任务请求和收集运行结果。主要方法有：
- __init__(self,number_workers,q_size,resq_size=0,poll_timeout=5):
  
  建立线程池，并启动对应的num_workers的线程；q_size表示任务请求队列的大小，resq_size表示存放运行结果队列的大小。
- createWorkers(self,num_workers，poll_timeout=5):
  
  将num_workers数量对应的线程加入线程池
- dismissWorkers(self,num_workers,do_join=False):
  
  告诉num_workers数量的工作线程在执行完当前任务后退出
- joinAllDismissWorkers(self):
  
  在设置为退出的线程上执行Thread.join
- putRequest(self,request,block=True,timeout=None):
  
  加入一个任务请求到工作队列
- pool(self,block=False)
  
  处理任务队列中新请求。也就是循环的调用各个线程结果中的回调和错误回调。不过，当请求队列为空时会抛出 NoResultPending 异常，以表示所有的结果都处理完了。这个特点对于依赖线程执行结果继续加入请求队列的方式不太适合。
- wait(self)
  
  等待执行结果，直到所有任务完成。当所有执行结果返回后，线程池内部的线程并没有销毁，而是在等待新任务。因此，wait()之后依然可以在此调用pool.putRequest()往其中添加任务。
threadpool.WorkerThread:处理任务的工作线程，主要有run()方法和dismiss()方法。
threadpool.WorkRequest:任务请求类，包含有具体执行方法的工作请求类
- __init__(self,callable,args=None,kwds=None,requestID=None,callback=None,exc_callback=None)
  
  创建一个工作请求。
makeRequests(callable_,args_list,callback=None,exc_callback=_handle_thread_exception):

主要函数，用来创建具有相同的执行函数但参数不同的一系列工作请求。

有了上面自定义线程池模式的基础，这个模块不难理解，有兴趣的可以去看看该模块的源码。它的使用步骤一般如下：

（1）引入threadpool模块
（2）定义线程函数
（3）创建线程池threadpool.ThreadPool()
（4）创建需要线程池处理的任务即threadpool.makeRequests()
（5）将创建的多个任务put到线程池中,threadpool.putRequest
（6）等到所有任务处理完毕theadpool.pool()

将上面的例子用线程池模块进行修改，代码如下：

import threadpool
if __name__ == "__main__":
    urls = [
        'http://www.python.org',
        'http://www.python.org/about/',
        'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
        'http://www.python.org/doc/',
        'http://www.python.org/download/',
        'http://www.python.org/getit/',
        'http://www.python.org/community/',
        'https://wiki.python.org/moin/',
        'http://planet.python.org/',
        'https://wiki.python.org/moin/LocalUserGroups',
        'http://www.python.org/psf/',
        'http://docs.python.org/devguide/',
        'http://www.python.org/community/awards/'
    ]
    t1 = datetime.datetime.now()
    pool = threadpool.ThreadPool(2)

    requests = threadpool.makeRequests(open_url,urls)
    [pool.putRequest(req) for req in requests]
    pool.wait()
    t2 = datetime.datetime.now()
    print t2-t1

执行结果如下：

multiprocessing.dummy 执行多线程任务

multiprocessing.dummy 模块与 multiprocessing 模块的区别： dummy 模块是多线程，而 multiprocessing 是多进程， api 都是通用的。

Python3里的multiprocessing里也有现成的线程池，如下

1	from multiprocessing.pool import ThreadPool

有时候看到有人这么用dummy,from multiprocessing.dummy import Pool as ThreadPool ,把它当作了一个线程池。它的属性和方法可以参考进程池。将上面的例子可以用这种方法改下代码如下：

from multiprocessing.dummy import Pool as ThreadPool 
if __name__ == "__main__":
    urls = [
        'http://www.python.org',
        'http://www.python.org/about/',
        'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
        'http://www.python.org/doc/',
        'http://www.python.org/download/',
        'http://www.python.org/getit/',
        'http://www.python.org/community/',
        'https://wiki.python.org/moin/',
        'http://planet.python.org/',
        'https://wiki.python.org/moin/LocalUserGroups',
        'http://www.python.org/psf/',
        'http://docs.python.org/devguide/',
        'http://www.python.org/community/awards/'
    ]
    t1 = datetime.datetime.now()
    pool =ThreadPool(2)
    pool.map(open_url,urls)
    pool.close()
    pool.join()
    t2 = datetime.datetime.now()
    print t2-t1

运行结果如下：

原文： https://blog.51cto.com/u_11026142/1879245