线程池和进程池

进程池：

进程池的使用有四种方式：apply_async、apply、map_async、map。其中apply_async和map_async是异步的，也就是启动进程函数之后会继续执行后续的代码不用等待进程函数返回。apply_async和map_async方式提供了一写获取进程函数状态的函数：ready()、successful()、get()。

PS：join()语句要放在close()语句后面。

http://blog.csdn.net/xiemanr/article/details/71746561

from multiprocessing import Pool  # 进程池                   from multiprocessing.dummy import Pool as ThreadPool  # 线程池

pool.join()是用来等待进程池中的worker进程执行完毕，防止主进程在worker进程结束前结束。
但pool.join()必须使用在pool.close()或者pool.terminate()之后。
其中close()跟terminate()的区别在于close()会等待池中的worker进程执行结束再关闭pool,而terminate()则是直接关闭。
ThreadPool()和Pool()，默认启动的进程/线程数都为CPU数，如果python获取不到CPU数则默认为1
一般计算(CPU)密集型任务适合多进程，IO密集型任务适合多线程，视具体情况而定，如http请求等等待时间较长的情况就属于IO密集型，让开销更小的线程去等待。

多线程是指一个程序中包含多个执行流，多线程是实现并发的一种有效手段。一个进程在其执行过程中，可以产生多个线程，形成多个执行流。每个执行流即每个线程也有它自身的产生、存在和消亡的过程。 

多线程程序设计的含义就是可以将程序任务分成几个并行的子任务。

Python中线程multiprocessing使用的同一模块。使用方法也基本相同，唯一不同的是，from multiprocessing import Pool这样导入的Pool表示的是进程池； 

from multiprocessing.dummy import Pool这样导入的Pool表示的是线程池。这样就可以实现线程里面的并发了。

Queue模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

线程池实例：

import time
from multiprocessing.dummy import Pool as ThreadPool
#给线程池取一个别名ThreadPool
def run(fn):
  time.sleep(2)
  print fn

if __name__ == '__main__':
  testFL = [1,2,3,4,5]
  pool = ThreadPool(10)#创建10个容量的线程池并发执行
  pool.map(run, testFL)
  pool.close()
  pool.join()

针对join()函数用法的实例：

# encoding: UTF-8
import threading
import time

def context(tJoin):
    print 'in threadContext.'
    tJoin.start()
    # 将阻塞tContext直到threadJoin终止。
    tJoin.join()
    # tJoin终止后继续执行。
    print 'out threadContext.'

def join():
    print 'in threadJoin.'
    time.sleep(1)
    print 'out threadJoin.'

tJoin = threading.Thread(target=join)
tContext = threading.Thread(target=context, args=(tJoin,))
tContext.start()

• 1
• 2

执行结果：

in threadContext.
in threadJoin.
out threadJoin.
out threadContext.

解析： 
主程序中这句tJoin = threading.Thread(target=join)执行后，只是创建了一个线程对象tJoin，但并未启动该线程。

tContext = threading.Thread(target=context, args=(tJoin,))
tContext.start()

• 1
• 2
• 3

上面这两句执行后，创建了另一个线程对象tContext并启动该线程（打印in threadContext.），同时将tJoin线程对象作为参数传给context函数，在context函数中，启动了tJoin这个线程，同时该线程又调用了join()函数（tJoin.join()），那tContext线程将等待tJoin这线程执行完成后，才能继续tContext线程后面的，所以先执行join()函数，打印输出下面两句：

in threadJoin.
out threadJoin.

• 1
• 2
• 3

tJoin线程执行结束后，继续执行tContext线程，于是打印输出了out threadContext.，于是就看到我们上面看到的输出结果，并且无论执行多少次，结果都是这个顺序。但如果将context()函数中tJoin.join()这句注释掉，再执行该程序，打印输出的结果顺序就不定了，因为此时这两线程就是并发执行的。