一，并发与并行

并发：CPU使用一个核心在各程序之间交替执行，形成一种让人以为程序同时运行的错觉，并不会真正的提升执行效率和速度

并行：CPU使用多个核心同时执行多个程序，各程序指令运行在不同的CPU内核上面，程序平行的向前推进，可以真正的提升执行速度

二，遗留问题

Python多线程只能使用一个核心，解释器的设计遗留问题

利用CPU多核只能通过多进程，或者在线程中使用C语言扩展

三，使用ThreadLocal来读写全局变量

多线程共享全局变量，非常容易把全局变量改乱，所以在全局变量声明ThreadLocal对象实例(可以理解为一个dict)，在其对象上绑定的所有属性数据，在每个线程中都是独立的，不同的

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等

四，线程对比进程

多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。

首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。

如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。

如果用多线程实现Master-Worker，主线程就是Master，其他线程就是Worker。

多进程模式最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。(当然主进程挂了所有进程就全挂了，但是Master进程只负责分配任务，挂掉的概率低)著名的Apache最早就是采用多进程模式。

多进程模式的缺点是创建进程的代价大，在Unix/Linux系统下，用fork调用还行，在Windows下创建进程开销巨大。另外，操作系统能同时运行的进程数也是有限的，在内存和CPU的限制下，如果有几千个进程同时运行，操作系统连调度都会成问题。

多线程模式通常比多进程快一点，但是也快不到哪去，而且，多线程模式致命的缺点就是任何一个线程挂掉都可能直接造成整个进程崩溃，因为所有线程共享进程的内存。在Windows上，如果一个线程执行的代码出了问题，你经常可以看到这样的提示：“该程序执行了非法操作，即将关闭”，其实往往是某个线程出了问题，但是操作系统会强制结束整个进程。

在Windows下，多线程的效率比多进程要高，所以微软的IIS服务器默认采用多线程模式。由于多线程存在稳定性的问题，IIS的稳定性就不如Apache。为了缓解这个问题，IIS和Apache现在又有多进程+多线程的混合模式，真是把问题越搞越复杂。

线程切换

无论是多进程还是多线程，只要数量一多，效率肯定上不去，为什么呢？

我们打个比方，假设你不幸正在准备中考，每天晚上需要做语文、数学、英语、物理、化学这5科的作业，每项作业耗时1小时。

如果你先花1小时做语文作业，做完了，再花1小时做数学作业，这样，依次全部做完，一共花5小时，这种方式称为单任务模型，或者批处理任务模型。

假设你打算切换到多任务模型，可以先做1分钟语文，再切换到数学作业，做1分钟，再切换到英语，以此类推，只要切换速度足够快，这种方式就和单核CPU执行多任务是一样的了，以幼儿园小朋友的眼光来看，你就正在同时写5科作业。

但是，切换作业是有代价的，比如从语文切到数学，要先收拾桌子上的语文书本、钢笔(这叫保存现场)，然后，打开数学课本、找出圆规直尺(这叫准备新环境)，才能开始做数学作业。操作系统在切换进程或者线程时也是一样的，它需要先保存当前执行的现场环境(CPU寄存器状态、内存页等)，然后，把新任务的执行环境准备好(恢复上次的寄存器状态，切换内存页等)，才能开始执行。这个切换过程虽然很快，但是也需要耗费时间。如果有几千个任务同时进行，操作系统可能就主要忙着切换任务，根本没有多少时间去执行任务了，这种情况最常见的就是硬盘狂响，点窗口无反应，系统处于假死状态。

所以，多任务一旦多到一个限度，就会消耗掉系统所有的资源，结果效率急剧下降，所有任务都做不好。

计算密集型 vs. IO密集型

是否采用多任务的第二个考虑是任务的类型。我们可以把任务分为计算密集型和IO密集型。

计算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，所以，要最高效地利用CPU，计算密集型任务同时进行的数量应当等于CPU的核心数。

计算密集型任务由于主要消耗CPU资源，因此，代码运行效率至关重要。Python这样的脚本语言运行效率很低，完全不适合计算密集型任务。对于计算密集型任务，最好用C语言编写。

第二种任务的类型是IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成(因为IO的速度远远低于CPU和内存的速度)。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是IO密集型任务，比如Web应用。

IO密集型任务执行期间，99%的时间都花在IO上，花在CPU上的时间很少，因此，用运行速度极快的C语言替换用Python这样运行速度极低的脚本语言，完全无法提升运行效率。对于IO密集型任务，最合适的语言就是开发效率最高(代码量最少)的语言，脚本语言是首选，C语言最差。

异步IO

考虑到CPU和IO之间巨大的速度差异，一个任务在执行的过程中大部分时间都在等待IO操作，单进程单线程模型会导致别的任务无法并行执行，因此，我们才需要多进程模型或者多线程模型来支持多任务并发执行。

现代操作系统对IO操作已经做了巨大的改进，最大的特点就是支持异步IO。如果充分利用操作系统提供的异步IO支持，就可以用单进程单线程模型来执行多任务，这种全新的模型称为事件驱动模型，Nginx就是支持异步IO的Web服务器，它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上，可以运行多个进程(数量与CPU核心数相同)，充分利用多核CPU。由于系统总的进程数量十分有限，因此操作系统调度非常高效。用异步IO编程模型来实现多任务是一个主要的趋势。

对应到Python语言，单线程的异步编程模型称为协程，有了协程的支持，就可以基于事件驱动编写高效的多任务程序。我们会在后面讨论如何编写协程。

五，可以使用multiprocessing.managers实现分布式进程共享通信处理内容

what？

进程和线程的概念：

进程是资源占用的最小单位

线程是内核调度执行的最小单位

进程和线程的主要区别：

进程之间是彼此独立的，由master进程通过fork()系统调用派生子进程

线程是共享内存空间的，主线程派生子线程

why？

进程和线程的优缺点：

进程：

优点：进程由于各自有独立的内存空间，所以更加稳定，子进程之间不受影响，但是主进程崩溃会导致全局，而且在python中不受GIL(全局解释器锁)限制，可以充分利用多核cpu

缺点：对于内存资源占用比较高，而且创建一个进程的代价比线程要大

线程：

优点：由于共享内存空间，所以资源占用比较小，并且创建的代价小于进程，在python中受到GIL的限制，导致只能使用一个cpu核心，所以某一时刻运行的线程只有一个

缺点：由于共享内存空间也导致了缺点，资源征用的问题(python中可以通过锁的机制限制)，并且一个线程的崩溃可能导致整个进程崩溃

fork()系统调用：

是unix/linux上比较特殊的一个系统调用，用于创建子进程，其特殊之处在于其他的系统调用函数一般调用一次返回一次，fork()调用一个返回两次(父进程pid+子进程pid)，且fork()调用时返回的子进程pid永远为0

where？(python中考虑)

多进程和多线程的共同目标是实现多任务

任务类型：cpu密集型和io密集型

cpu密集型：应该使用多进程，充分利用多核cpu实现真正意义上的并发执行

io密集型：可以使用多线程，节约资源

how？

在python中怎样使用多进程和多线程编程？

多线程

python对于多线程的支持提供了两个基础库，较为底层的thread模块和较为高层的threading模块

实现原理：

将准备并发执行的代码当做参数传递给threading.Thread()创建一个线程对象，结合程序控制结构(循环)等方式来完成此线程对象start()的多次调用，从而实现多线程

示例代码：(利用多线程实现并发socket通信服务端)

import threading  ##导入线程库

import socket    ##导入socket

s=socket.socket()   #创建socket对象

s.bind(('0.0.0.0',8888))   #绑定套接字

s.listen(10)         #监听套接字

def run():            #定义处理函数

sock,addr=s.accept()

while True:

a=sock.recv(1024)

if a:

sock.send(a.upper())

else:

sock.close()

break

if __name__ =='__main__':

for i in xrange(20):    #根据for循环创建20个线程

t=threading.Thread(target=run)   #创建线程对象

t.start()    #运行线程

此示例的第二种写法：

import threading  ##导入线程库

import socket    ##导入socket

s=socket.socket()   #创建socket对象

s.bind(('0.0.0.0',8888))   #绑定套接字

s.listen(10)         #监听套接字

class Mythread(threading.Thread):

def run(self):            #定义处理函数

sock,addr=s.accept()

while True:

a=sock.recv(1024)

if a:

sock.send(a.upper())

else:

sock.close()

break

if __name__ =='__main__':

for i in xrange(20):    #根据for循环创建20个线程

t=Mythread()   #创建线程对象

t.start()    #运行线程

2.多进程

python提供可multiprocessing模块中的Process类来创建进程对象，同时该模块还提供了Pool类来创建进程池对象，以及Queue和Pipe实现进程间通信

实现原理：

将准备并发执行的代码当做参数传递给multiprocessing.Process()创建一个进程对象，结合程序控制结构(循环)等方式来完成此进程对象start()的多次调用，从而实现多进程

示例代码：(利用多进程实现并发socket通信服务端)

import multiprocessing  ##导入线程库

import socket    ##导入socket

s=socket.socket()   #创建socket对象

s.bind(('0.0.0.0',8888))   #绑定套接字

s.listen(10)         #监听套接字

def run():            #定义处理函数

sock,addr=s.accept()

while True:

a=sock.recv(1024)

if a:

sock.send(a.upper())

else:

sock.close()

break

if __name__ =='__main__':

for i in xrange(20):    #根据for循环创建20个线程

t=multiprocess.Process(target=run)   #创建线程对象

t.start()    #运行线程

//可以使用ps aux | grep python 查看已经运行了20个进程

同上:也可以自定义类并继承Process类再实例化对象的方式进行编写

总结：对于多任务的情形，并发是不可避免的问题，多进程和多线程可以实现并发，但是由于其都有不可避免的缺陷，所以如何让单进程或单线程实现并发任务的处理，如nginx，就需要使用异步IO的机制，基于事件驱动，在python中实现此机制的称为协程。