本文主要介绍python异步并发模块concurrent.futures。它非常简单易用，主要用来实现多线程和多进程的异步并发。
1. 模块安装
1) python 3.x中自带了concurrent.futures模块
2) python 2.7需要安装futures模块，使用命令pip install futures安装即可
pypi地址：https://pypi.python.org/pypi/futures/
2. Executor对象
class concurrent.futures.Executor
Executor是一个抽象类，它提供了异步执行调用的方法。它不能直接使用，但可以通过它的两个子类ThreadPoolExecutor或者ProcessPoolExecutor进行调用。
2.1 Executor.submit(fn, *args, **kwargs)
fn：需要异步执行的函数
*args, **kwargs：fn参数
示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#-*- coding:utf-8 -*-from concurrent import futuresdef test(num): import time return time.ctime(),numwith futures.ThreadPoolExecutor(max_workers=1) as executor: future = executor.submit(test,1) print future.result()>>>(\'Tue Jan 17 15:23:10 2017\', 1) |
2.2 Executor.map(func, *iterables, timeout=None)
相当于map(func, *iterables)，但是func是异步执行。timeout的值可以是int或float，如果操作超时，会返回raisesTimeoutError；如果不指定timeout参数，则不设置超时间。
func：需要异步执行的函数
*iterables：可迭代对象，如列表等。每一次func执行，都会从iterables中取参数。
timeout：设置每次异步操作的超时时间
示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#-*- coding:utf-8 -*-from concurrent import futuresdef test(num): import time return time.ctime(),numdata=[1,2,3]with futures.ThreadPoolExecutor(max_workers=1) as executor: for future in executor.map(test,data): print future>>>(\'Tue Jan 17 15:23:47 2017\', 1)(\'Tue Jan 17 15:23:47 2017\', 2)(\'Tue Jan 17 15:23:47 2017\', 3) |
2.3 Executor.shutdown(wait=True)
释放系统资源,在Executor.submit()或 Executor.map()等异步操作后调用。使用with语句可以避免显式调用此方法。
3. ThreadPoolExecutor对象
ThreadPoolExecutor类是Executor子类，使用线程池执行异步调用.
class concurrent.futures.ThreadPoolExecutor(max_workers)
使用max_workers数目的线程池执行异步调用
4. ProcessPoolExecutor对象
ThreadPoolExecutor类是Executor子类，使用进程池执行异步调用.
class concurrent.futures.ProcessPoolExecutor(max_workers=None)
使用max_workers数目的进程池执行异步调用，如果max_workers为None则使用机器的处理器数目（如4核机器max_worker配置为None时，则使用4个进程进行异步并发）。
示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#-*- coding:utf-8 -*-from concurrent import futuresdef test(num): import time return time.ctime(),numdef muti_exec(m,n): #m 并发次数 #n 运行次数 with futures.ProcessPoolExecutor(max_workers=m) as executor: #多进程 #with futures.ThreadPoolExecutor(max_workers=m) as executor: #多线程 executor_dict=dict((executor.submit(test,times), times) for times in range(m*n)) for future in futures.as_completed(executor_dict): times = executor_dict[future] if future.exception() is not None: print(\'%r generated an exception: %s\' % (times,future.exception())) else: print(\'RunTimes:%d,Res:%s\'% (times, future.result()))if __name__ == \'__main__\': muti_exec(5,1)>>>RunTimes:0,Res:(\'Tue Jan 17 15:56:53 2017\', 0)RunTimes:4,Res:(\'Tue Jan 17 15:56:53 2017\', 4)RunTimes:3,Res:(\'Tue Jan 17 15:56:53 2017\', 3)RunTimes:1,Res:(\'Tue Jan 17 15:56:53 2017\', 1)RunTimes:2,Res:(\'Tue Jan 17 15:56:53 2017\', 2) |
5. Python GIL相关
要理解GIL的含义，我们需要从Python的基础讲起。像C++这样的语言是编译型语言，所谓编译型语言，是指程序输入到编译器，编译器再根据语言的语 法进行解析，然后翻译成语言独立的中间表示，最终链接成具有高度优化的机器码的可执行程序。编译器之所以可以深层次的对代码进行优化，是因为它可以看到整 个程序（或者一大块独立的部分）。这使得它可以对不同的语言指令之间的交互进行推理，从而给出更有效的优化手段。
与此相反，Python是解释型语言。程序被输入到解释器来运行。解释器在程序执行之前对其并不了解；它所知道的只是Python的规则，以及在执行过程 中怎样去动态的应用这些规则。它也有一些优化，但是这基本上只是另一个级别的优化。由于解释器没法很好的对程序进行推导，Python的大部分优化其实是 解释器自身的优化。
现在我们来看一下问题的症结所在。要想利用多核系统，Python必须支持多线程运行。作为解释型语言，Python的解释器必须做到既安全又高效。我们都知道多线程编程会遇到的问题，解释器要留意的是避免在不同的线程操作内部共享的数据，同时它还要保证在管理用户线程时保证总是有最大化的计算资源。
那么，不同线程同时访问时，数据的保护机制是怎样的呢？答案是解释器全局锁。从名字上看能告诉我们很多东西，很显然，这是一个加在解释器上的全局（从解释器的角度看）锁（从互斥或者类似角度看）。这种方式当然很安全，但是它有一层隐含的意思（Python初学者需要了解这个）：对于任何Python程序，不管有多少的处理器，任何时候都总是只有一个线程在执行。
”为什么我全新的多线程Python程序运行得比其只有一个线程的时候还要慢？“许多人在问这个问题时还是非常犯晕的，因为显然一个具有两个线程的程序要比其只有一个线程时要快（假设该程序确实是可并行的）。事实上，这个问题被问得如此频繁以至于Python的专家们精心制作了一个标准答案：”不要使用多线程，请使用多进程”。
所以，对于计算密集型的，我还是建议不要使用python的多线程而是使用多进程方式，而对于IO密集型的，还是劝你使用多进程方式，因为使用多线程方式出了问题，最后都不知道问题出在了哪里，这是多么让人沮丧的一件事情！
6. 参考文档