python多进程协程

1. 在python中线程和协程的区别是什么

在python中线程和协程的区别：1、一个线程可以拥有多个协程，这样在python中就能使用多核CPU；2、线程是同步机制，而协程是异步；3、 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。

一、首先我们来了解一下线程和协程的概念

1、线程

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

2、协程

协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

二、协程与线程的比较

1) 一个线程可以拥有多个协程，一个进程也可以单独拥有多个协程，这样python中则能使用多核CPU。

2) 线程进程都是同步机制，而协程则是异步。

3)协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。

三、线程、协程在python中的使用

1、多线程一般是使用threading库，完成一些IO密集型并发操作。多线程的优势是切换快，资源消耗低，但一个线程挂掉则会影响到所有线程，所以不够稳定。现实中使用线程池的场景会比较多，具体可参考《python线程池实现》。

2、协程一般是使用gevent库，当然这个库用起来比较麻烦，所以使用的并不是很多。相反，协程在tornado的运用就多得多了，使用协程让tornado做到单线程异步，据说还能解决C10K的问题。所以协程使用的地方最多的是在web应用上。

总结一下：

IO密集型一般使用多线程或者多进程，CPU密集型一般使用多进程，强调非阻塞异步并发的一般都是使用协程，当然有时候也是需要多进程线程池结合的，或者是其他组合方式。

推荐课程：Python高级进阶视频教程

2. Python 进程，线程，协程，锁机制，你知多少

1.线程和进程：
线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

2.线程、进程与协程：
线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保持状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。
协程的适用场景： 当程序中存在大量不需要CPU的操作时（IO），适用于协程；

3. python多进程和多线程的区别

进程是程序（软件，应用）的一个执行实例，每个运行中的程序，可以同时创建多个进程，但至少要有一个。每个进程都提供执行程序所需的所有资源，都有一个虚拟的地址空间、可执行的代码、操作系统的接口、安全的上下文（记录启动该进程的用户和权限等等）、唯一的进程ID、环境变量、优先级类、最小和最大的工作空间（内存空间）。进程可以包含线程，并且每个进程必须有至少一个线程。每个进程启动时都会最先产生一个线程，即主线程，然后主线程会再创建其他的子线程。

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不独立拥有系统资源，但它可与同属一个进程的其它线程共享该进程所拥有的全部资源。每一个应用程序都至少有一个进程和一个线程。在单个程序中同时运行多个线程完成不同的被划分成一块一块的工作，称为多线程。

举个例子，某公司要生产一种产品，于是在生产基地建设了很多厂房，每个厂房内又有多条流水生产线。所有厂房配合将整个产品生产出来，单个厂房内的流水线负责生产所属厂房的产品部件，每个厂房都拥有自己的材料库，厂房内的生产线共享这些材料。公司要实现生产必须拥有至少一个厂房一条生产线。换成计算机的概念，那么这家公司就是应用程序，厂房就是应用程序的进程，生产线就是某个进程的一个线程。

线程的特点：

线程是一个execution context（执行上下文），即一个cpu执行时所需要的一串指令。假设你正在读一本书，没有读完，你想休息一下，但是你想在回来时继续先前的进度。有一个方法就是记下页数、行数与字数这三个数值，这些数值就是execution context。如果你的室友在你休息的时候，使用相同的方法读这本书。你和她只需要这三个数字记下来就可以在交替的时间共同阅读这本书了。

线程的工作方式与此类似。CPU会给你一个在同一时间能够做多个运算的幻觉，实际上它在每个运算上只花了极少的时间，本质上CPU同一时刻只能干一件事，所谓的多线程和并发处理只是假象。CPU能这样做是因为它有每个任务的execution context，就像你能够和你朋友共享同一本书一样。

进程与线程区别：

• 同一个进程中的线程共享同一内存空间，但进程之间的内存空间是独立的。

• 同一个进程中的所有线程的数据是共享的，但进程之间的数据是独立的。

• 对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除以外）不会影响其他子进程。

• 线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。

• 同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代理来实现。

• 创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。

• 一个线程可以操作同一进程的其他线程，但是进程只能操作其子进程。

• 线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。

由于现代cpu已经进入多核时代，并且主频也相对以往大幅提升，多线程和多进程编程已经成为主流。Python全面支持多线程和多进程编程，同时还支持协程。

4. python中的协程是怎么实现多任务的

协程也称为微线程，是在一个线程中，通过不断的切换任务函数实现了多任务的效果。
协程在python实现的原理主要是通过yield这个关键字实现
但是真正在开发时，可以不需要自己实现，可以通过很多成熟的第三方模块来实现协程，比如greenlet,gevent等模块。黑马程序员可学习Python哦，有免费的学习视频，学习路线图，学习工具！

5. 多线程 python和多进程的区别

多进程共享资源必然会带来进程间相互竞争。
而这种竞争又会造成race condition，我们的结果有可能被竞争的不确定性所影响。
但如果需要，我们依然可以通过共享内存和Manager对象这么做。

6. Python怎么多线程中添加协程

由于python是一种解释性脚本语言，python的多线程在运行过程中始终存在全局线程锁。
简单的来说就是在实际的运行过程中，python只能利用一个线程，因此python的多线程并不达到C语言多线程的性能。
可以使用多进程来代替多线程，但需要注意的是多进程最好不要涉及到例如文件操作的频繁操作IO的功能。

7. 详解Python中的协程，为什么说它的底层是生成器

协程又称为是微线程，英文名是Coroutine。它和线程一样可以调度，但是不同的是线程的启动和调度需要通过操作系统来处理。并且线程的启动和销毁需要涉及一些操作系统的变量申请和销毁处理，需要的时间比较长。而协程呢，它的调度和销毁都是程序自己来控制的，因此它更加轻量级也更加灵活。

协程有这么多优点，自然也会有一些缺点，其中最大的缺点就是需要编程语言自己支持，否则的话需要开发者自己通过一些方法来实现协程。对于大部分语言来说，都不支持这一机制。go语言由于天然支持协程，并且支持得非常好，使得它广受好评，短短几年时间就迅速流行起来。

对于Python来说，本身就有着一个GIL这个巨大的先天问题。GIL是Python的全局锁，在它的限制下一个Python进程同一时间只能同时执行一个线程，即使是在多核心的机器当中。这就大大影响了Python的性能，尤其是在CPU密集型的工作上。所以为了提升Python的性能，很多开发者想出了使用多进程+协程的方式。一开始是开发者自行实现的，后来在Python3.4的版本当中，官方也收入了这个功能，因此目前可以光明正大地说，Python是支持协程的语言了。

生成器（generator)

生成器我们也在之前的文章当中介绍过，为什么我们介绍协程需要用到生成器呢，是因为Python的协程底层就是通过生成器来实现的。

通过生成器来实现协程的原因也很简单，我们都知道协程需要切换挂起，而生成器当中有一个yield关键字，刚好可以实现这个功能。所以当初那些自己在Python当中开发协程功能的程序员都是通过生成器来实现的，我们想要理解Python当中协程的运用，就必须从最原始的生成器开始。

生成器我们很熟悉了，本质上就是带有yield这个关键词的函数。

async，await和future

从Python3.5版本开始，引入了async，await和future。我们来简单说说它们各自的用途，其中async其实就是@asyncio.coroutine，用途是完全一样的。同样await代替的是yield from，意为等待另外一个协程结束。

我们用这两个一改，上面的代码就成了：

async def test(k):

n = 0

while n < k:

await asyncio.sleep(0.5)

print('n = {}'.format(n))

n += 1

由于我们加上了await，所以每次在打印之前都会等待0.5秒。我们把await换成yield from也是一样的，只不过用await更加直观也更加贴合协程的含义。

Future其实可以看成是一个信号量，我们创建一个全局的future，当一个协程执行完成之后，将结果存入这个future当中。其他的协程可以await future来实现阻塞。我们来看一个例子就明白了：

future = asyncio.Future()

async def test(k):

n = 0

while n < k:

await asyncio.sleep(0.5)

print('n = {}'.format(n))

n += 1

future.set_result('success')

async def log():

result = await future

print(result)

loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.wait([

log(),

test(5)

]))

loop.close()

在这个例子当中我们创建了两个协程，第一个协程是每隔0.5秒print一个数字，在print完成之后把success写入到future当中。第二个协程就是等待future当中的数据，之后print出来。

在loop当中我们要调度执行的不再是一个协程对象了而是两个，所以我们用asyncio当中的wait将这两个对象包起来。只有当wait当中的两个对象执行结束，wait才会结束。loop等待的是wait的结束，而wait等待的是传入其中的协程的结束，这就形成了一个依赖循环，等价于这两个协程对象结束，loop才会结束。

总结

async并不只是可以用在函数上，事实上还有很多其他的用法，比如用在with语句上，用在for循环上等等。这些用法比较小众，细节也很多，就不一一展开了，大家感兴趣的可以自行去了解一下。

不知道大家在读这篇文章的过程当中有没有觉得有些费劲，如果有的话，其实是很正常的。原因也很简单，因为Python原生是不支持协程这个概念的，所以在一开始设计的时候也没有做这方面的准备，是后来觉得有必要才加入的。那么作为后面加入的内容，必然会对原先的很多内容产生影响，尤其是协程借助了之前生成器的概念来实现的，那么必然会有很多耦合不清楚的情况。这也是这一块的语法很乱，对初学者不友好的原因。

8. python中多进程+协程的使用以及为什么要用它

前面讲了为什么python里推荐用多进程而不是多线程，但是多进程也有其自己的限制：相比线程更加笨重、切换耗时更长，并且在python的多进程下，进程数量不推荐超过CPU核心数（一个进程只有一个GIL，所以一个进程只能跑满一个CPU），因为一个进程占用一个CPU时能充分利用机器的性能，但是进程多了就会出现频繁的进程切换，反而得不偿失。

不过特殊情况（特指IO密集型任务）下，多线程是比多进程好用的。

举个例子：给你200W条url，需要你把每个url对应的页面抓取保存起来，这种时候，单单使用多进程，效果肯定是很差的。为什么呢？

例如每次请求的等待时间是2秒，那么如下（忽略cpu计算时间）：

1、单进程+单线程：需要2秒*200W=400W秒==1111.11个小时==46.3天，这个速度明显是不能接受的

2、单进程+多线程：例如我们在这个进程中开了10个多线程，比1中能够提升10倍速度，也就是大约4.63天能够完成200W条抓取，请注意，这里的实际执行是：线程1遇见了阻塞，CPU切换到线程2去执行，遇见阻塞又切换到线程3等等，10个线程都阻塞后，这个进程就阻塞了，而直到某个线程阻塞完成后，这个进程才能继续执行，所以速度上提升大约能到10倍（这里忽略了线程切换带来的开销，实际上的提升应该是不能达到10倍的），但是需要考虑的是线程的切换也是有开销的，所以不能无限的启动多线程（开200W个线程肯定是不靠谱的）

3、多进程+多线程：这里就厉害了，一般来说也有很多人用这个方法，多进程下，每个进程都能占一个cpu，而多线程从一定程度上绕过了阻塞的等待，所以比单进程下的多线程又更好使了，例如我们开10个进程，每个进程里开20W个线程，执行的速度理论上是比单进程开200W个线程快10倍以上的（为什么是10倍以上而不是10倍，主要是cpu切换200W个线程的消耗肯定比切换20W个进程大得多，考虑到这部分开销，所以是10倍以上）。

还有更好的方法吗？答案是肯定的，它就是：

4、协程，使用它之前我们先讲讲what/why/how（它是什么/为什么用它/怎么使用它）

what：

协程是一种用户级的轻量级线程。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

在并发编程中，协程与线程类似，每个协程表示一个执行单元，有自己的本地数据，与其它协程共享全局数据和其它资源。

why：

目前主流语言基本上都选择了多线程作为并发设施，与线程相关的概念是抢占式多任务（Preemptive multitasking），而与协程相关的是协作式多任务。

不管是进程还是线程，每次阻塞、切换都需要陷入系统调用(system call)，先让CPU跑操作系统的调度程序，然后再由调度程序决定该跑哪一个进程(线程)。
而且由于抢占式调度执行顺序无法确定的特点，使用线程时需要非常小心地处理同步问题，而协程完全不存在这个问题（事件驱动和异步程序也有同样的优点）。

因为协程是用户自己来编写调度逻辑的，对CPU来说，协程其实是单线程，所以CPU不用去考虑怎么调度、切换上下文，这就省去了CPU的切换开销，所以协程在一定程度上又好于多线程。

how:

python里面怎么使用协程？答案是使用gevent，使用方法：看这里

使用协程，可以不受线程开销的限制，我尝试过一次把20W条url放在单进程的协程里执行，完全没问题。

所以最推荐的方法，是多进程+协程（可以看作是每个进程里都是单线程，而这个单线程是协程化的）

多进程+协程下，避开了CPU切换的开销，又能把多个CPU充分利用起来，这种方式对于数据量较大的爬虫还有文件读写之类的效率提升是巨大的。

小例子：

[python]view plain

• #-*-coding=utf-8-*-

• importrequests

• importgevent

• fromgeventimportmonkey;monkey.patch_all()

• importsys

• reload(sys)

• sys.setdefaultencoding('utf8')

• deffetch(url):

• try:

• s=requests.Session()

• r=s.get(url,timeout=1)#在这里抓取页面

• exceptException,e:

• printe

• return''

• defprocess_start(url_list):

• tasks=[]

• forurlinurl_list:

• tasks.append(gevent.spawn(fetch,url))

• gevent.joinall(tasks)#使用协程来执行

• deftask_start(filepath,flag=100000):#每10W条url启动一个进程

• withopen(filepath,'r')asreader:#从给定的文件中读取url

• url=reader.readline().strip()

• url_list=[]#这个list用于存放协程任务

• i=0#计数器，记录添加了多少个url到协程队列

• whileurl!='':

• i+=1

• url_list.append(url)#每次读取出url，将url添加到队列

• ifi==flag:#一定数量的url就启动一个进程并执行

• p=Process(target=process_start,args=(url_list,))

• p.start()

• url_list=[]#重置url队列

• i=0#重置计数器

• url=reader.readline().strip()

• ifurl_listnot[]:#若退出循环后任务队列里还有url剩余

• p=Process(target=process_start,args=(url_list,))#把剩余的url全都放到最后这个进程来执行

• p.start()

• if__name__=='__main__':

• task_start('./testData.txt')#读取指定文件





细心的同学会发现：上面的例子中隐藏了一个问题：进程的数量会随着url数量的增加而不断增加，我们在这里不使用进程池multiprocessing.Pool来控制进程数量的原因是multiprocessing.Pool和gevent有冲突不能同时使用，但是有兴趣的同学可以研究一下gevent.pool这个协程池。