进程与线程
进程
进程的定义：
进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。
举一例说明进程：
想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(cpu)，而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他
离开时的那一步继续做下去。
操作系统进程切换：
1 出现IO操作
2 固定时间
进程：资源管理单位（容器）
线程
线程的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，
使到进程内并发成为可能。
假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。是的，这种机制就是线程。
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。
进程与线程的关系
进程和线程的关系：
(1)一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
(2)资源分配给进程，同一进程的所有线程共享该进程的所有资源。
(3)cpu分给线程，即真正在cpu上运行的是线程
线程：最小执行单位
并行和并发
并行处理（Parallel Processing）是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。并发处理(concurrency Processing)：指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机(CPU)上运行，但任一个时刻点上只有一个程序在处理机(CPU)上运行
并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说，并行是并发的子集
threading模块
创建线程对象使用Thread类
import threading import time def ting(): print('听歌') time.sleep(3) print('听歌结束') def boke(x): print('%s写博客'%x) time.sleep(4) print('写博客结束') s = time.time() t1 = threading.Thread(target=ting) #生成一个线程实例，target=函数名，args=实参, t2 = threading.Thread(target=boke,args=('yang',))#生成一个线程实例，target=函数名，args=实参, t1.start() #启动线程 t2.start() #启动线程
Thread类继承式创建
import threading import time class MyThread(threading.Thread): #继承Thread类 def __init__(self,num): super().__init__() self.num = num def run(self): print('计时：%s'%self.num) time.sleep(3) t1 = MyThread(50) t2 = MyThread(60) t1.run() t2.run() print('ending....')
Thread类的实例方法
使用join()和setDaemon()
import threading import time def ting(): print('听歌',time.ctime()) time.sleep(3) print('听歌结束',time.ctime()) def boke(x): print('%s写博客%s'%(x,time.ctime())) time.sleep(4) print('%s写博客结束%s'%(x,time.ctime())) thread = [] t1 = threading.Thread(target=ting) t2 = threading.Thread(target=boke,args=('yang',)) thread.append(t1) thread.append(t2) if __name__ == '__main__': ''' setDaemon（）:绑定的对象，在运行的时候是不管的， 没有被绑定的什么时候结束主线程就什么时候结束（如果绑定的线程在没有绑定的线程里面，那么也会被执行) join():线程对象未执行完，会阻塞你的主线程。 ''' t1.setDaemon(True) for i in thread: i.start() # t2.join()#线程对象未执行完，会阻塞你的主线程。 print('ending...........')
其他的方法使用
Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。 threading模块提供的一些方法： # threading.currentThread(): 返回当前的线程变量。 # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
总结：
对于计算密集型任务：Python的多线程并没有用
对于IO密集型任务：Python的多线程是有意义的
python使用多核：开进程，弊端：开销大而且切换复杂
着重点：协程+多进程
方向：IO多路复用
终极思路：换C模块实现多线程
GIL(全局解释器锁)
Python中的线程是操作系统的原生线程，Python虚拟机使用一个全局解释器锁（Global Interpreter Lock）来互斥线程对Python虚拟机的使用。为了支持多线程机制，一个基本的要求就是需要实现不同线程对共享资源访问的互斥，所以引入了GIL。
GIL：在一个线程拥有了解释器的访问权之后，其他的所有线程都必须等待它释放解释器的访问权，即使这些线程的下一条指令并不会互相影响。
在调用任何Python C API之前，要先获得GIL
GIL缺点：多处理器退化为单处理器；优点：避免大量的加锁解锁操作
GIL的影响
无论你启多少个线程，你有多少个cpu, Python在执行一个进程的时候会淡定的在同一时刻只允许一个线程运行。
所以，python是无法利用多核CPU实现多线程的。
这样，python对于计算密集型的任务开多线程的效率甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。
1 #coding:utf8 2 from threading import Thread 3 import time 4 5 def counter(): 6 i = 0 7 for _ in range(50000000): 8 i = i + 1 9 10 return True 11 12 13 def main(): 14 15 l=[] 16 start_time = time.time() 17 18 for i in range(2): 19 20 t = Thread(target=counter) 21 t.start() 22 l.append(t) 23 t.join() 24 25 # for t in l: 26 # t.join() 27 28 end_time = time.time() 29 print("Total time: {}".format(end_time - start_time)) 30 31 if __name__ == '__main__': 32 main() 33 34 35 ''' 36 py2.7: 37 串行:25.4523348808s 38 并发:31.4084379673s 39 py3.5: 40 串行:8.62115597724914s 41 并发:8.99609899520874s 42 43 '''
解决方案
用multiprocessing替代Thread multiprocessing库的出现很大程度上是为了弥补thread库因为GIL而低效的缺陷。它完整的复制了一套thread所提供的接口方便迁移。唯一的不同就是它使用了多进程而不是多线程。每个进程有自己的独立的GIL，因此也不会出现进程之间的GIL争抢。
#coding:utf8 from multiprocessing import Process import time def counter(): i = 0 for _ in range(40000000): i = i + 1 return True def main(): l=[] start_time = time.time() for _ in range(2): t=Process(target=counter) t.start() l.append(t) #t.join() for t in l: t.join() end_time = time.time() print("Total time: {}".format(end_time - start_time)) if __name__ == '__main__': main() ''' py2.7: 串行:6.1565990448 s 并行:3.1639978885 s py3.5: 串行:6.556925058364868 s 并发:3.5378448963165283 s '''
当然multiprocessing也不是万能良药。它的引入会增加程序实现时线程间数据通讯和同步的困难。就拿计数器来举例子，如果我们要多个线程累加同一个变量，对于thread来说，申明一个global变量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由于进程之间无法看到对方的数据，只能通过在主线程申明一个Queue，put再get或者用share memory的方法。这个额外的实现成本使得本来就非常痛苦的多线程程序编码，变得更加痛苦了。
总结：因为GIL的存在，只有IO Bound场景下得多线程会得到较好的性能 - 如果对并行计算性能较高的程序可以考虑把核心部分也成C模块，或者索性用其他语言实现 - GIL在较长一段时间内将会继续存在，但是会不断对其进行改进。
所以对于GIL，既然不能反抗，那就学会去享受它吧！
同步锁 (Lock)
1 #!/usr/bin/python 2 # -*- coding: UTF-8 -*- 3 4 import time 5 import threading 6 def subnum(): 7 global num 8 9 # num -= 1 10 11 print('ok') 12 '''当第一次print打印的之后，运行lock.acquire()锁，然后运行里面的代码，到睡的阶段，这个时间在解释器里面时间很漫长， 13 所以会继续打印‘ok’,同时也没有锁，当第一次的睡眠时间结束之后，其他的线程会抢这个锁，来执行。''' 14 lock.acquire() 15 temp = num 16 time.sleep(0.001) 17 num = temp - 1 18 lock.release() 19 print('end.......') 20 21 num = 100 22 23 thread_list = [] 24 25 lock = threading.Lock() 26 27 for i in range(100):#运行100个子线程， 28 t = threading.Thread(target=subnum) 29 t.start() 30 thread_list.append(t) 31 32 for t in thread_list: 33 t.join() #线程对象未执行完，会阻塞你的主线程。 34 print('结果：%s'%num) 35 36 ''' 37 同步锁： 38 就相当于在线程里面添加一个join（）的阻塞功能，同时还不会影响线程里面的锁上面代码的运行， 39 但是会控制住解锁下面的代码。 40 '''
锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：
扩展思考
''' 1、为什么有了GIL，还需要线程同步？ 多线程环境下必须存在资源的竞争,那么如何才能保证同一时刻只有一个线程对共享资源进行存取? 加锁, 对, 加锁可以保证存取操作的唯一性, 从而保证同一时刻只有一个线程对共享数据存取. 通常加锁也有2种不同的粒度的锁: coarse-grained(粗粒度)： python解释器层面维护着一个全局的锁机制,用来保证线程安全。 内核级通过GIL实现的互斥保护了内核的共享资源。 fine-grained(细粒度)： 那么程序员需要自行地加,解锁来保证线程安全， 用户级通过自行加锁保护的用户程序的共享资源。 2、GIL为什么限定在一个进程上？ 你写一个py程序，运行起来本身就是一个进程，这个进程是有解释器来翻译的，所以GIL限定在当前进程； 如果又创建了一个子进程，那么两个进程是完全独立的，这个字进程也是有python解释器来运行的，所以 这个子进程上也是受GIL影响的 '''
死锁与递归锁
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
死锁：
#!/usr/bin/python # -*- coding: UTF-8 -*- import threading import time #产生死锁 mutexA = threading.Lock() mutexB = threading.Lock() #递归锁 mutex = threading.RLock() class MyThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): self.fun1() self.fun2() def fun1(self): mutexA.acquire() #count = 1 print('111I am %s ,get res: %s---%s'%(self.name,'resA',time.time())) mutexB.acquire() #count = 2 print('222I am %s ,get res: %s---%s'%(self.name,'resB',time.time())) mutexB.release() #count = 1 mutexA.release() #count =0 程序结束 def fun2(self): mutexB.acquire() #count = 1 print('333I am %s ,get res: %s---%s' % (self.name, 'resB', time.time())) mutexA.acquire() print('444I am %s ,get res: %s---%s' % (self.name, 'resA', time.time())) mutexA.release() mutexB.release() if __name__ == '__main__': print('start-------------------%s'%time.time()) for i in range(0,10): my_thread = MyThread() my_thread.start() ''' 同步锁：threading.Lock() 在两个进程同时使用，在进行切换的时候谁也不会先把自己有的锁给对方，那么这时就会产生死锁，无法往下进行 那么就需要使用，threading.Rlock()这个递归锁来解决死锁的问题。 锁一道的时候，就同步锁， 锁两道的时候，用递归锁， 最好都用递归锁。 acquire（）：锁 release()：解锁 '''
在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：
递归锁：
#!/usr/bin/python # -*- coding: UTF-8 -*- import threading import time ''' 同步锁：threading.Lock() 在两个进程同时使用，在进行切换的时候谁也不会先把自己有的锁给对方，那么这时就会产生死锁，无法往下进行 那么就需要使用，threading.Rlock()这个递归锁来解决死锁的问题。 锁一道的时候，就同步锁， 锁两道的时候，用递归锁， 最好都用递归锁。 acquire（）：锁 release()：解锁 ''' #下面是解决上述代码产生死锁的方法，使用递归锁 import threading import time #递归锁 mutex = threading.RLock() class MyThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): self.fun1() self.fun2() def fun1(self): mutex.acquire() #count = 1 print('111I am %s ,get res: %s---%s'%(self.name,'resA',time.time())) mutex.acquire() #count = 2 print('222I am %s ,get res: %s---%s'%(self.name,'resB',time.time())) mutex.release() #count = 1 mutex.release() #count =0 程序结束 def fun2(self): mutex.acquire() #count = 1 print('333I am %s ,get res: %s---%s' % (self.name, 'resB', time.time())) mutex.acquire() print('444I am %s ,get res: %s---%s' % (self.name, 'resA', time.time())) mutex.release() mutex.release() if __name__ == '__main__': print('start-------------------%s'%time.time()) for i in range(0,10): my_thread = MyThread() my_thread.start()
Event对象
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就 会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
event.isSet()：返回event的状态值； event.wait()：如果 event.isSet()==False将阻塞线程； event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度； event.clear()：恢复event的状态值为False。
可以考虑一种应用场景（仅仅作为说明），例如，我们有多个线程从Redis队列中读取数据来处理，这些线程都要尝试去连接Redis的服务，一般情况下，如果Redis连接不成功，在各个线程的代码中，都会去尝试重新连接。如果我们想要在启动时确保Redis服务正常，才让那些工作线程去连接Redis服务器，那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作：主线程中会去尝试连接Redis服务，如果正常的话，触发事件，各工作线程会尝试连接Redis服务。
#!/usr/bin/python # -*- coding: UTF-8 -*- import threading import time import logging #日志模块 logging.basicConfig(level=logging.DEBUG,format='(%(threadName)-10s) %(message)s',) def worker(event): logging.debug('Waiting for redis ready...') #不是ture的时候，循环下面的代码， while not event.isSet():#返回event的状态值 logging.debug('wait........') #打印 #event.wait（）：为空的时候，需要event = ture才会继续往下运行。如果有参数，就是等待多少秒才会执行 ''' 在运行整个等待的3秒的时候，main（）函数的睡眠也同时在等待，在这个3秒结束了，会在进行一次循环，打印上面的语句，在到这个睡眠， 当这个睡眠结束的时候，main()函数里面的6秒也结束了，flag = True ,也就结束这个循环，运行下面的代码。 ''' event.wait(3) #if flag = Flase阻塞，等待flag = True继续执行 logging.debug('redis ready, and connect to redis server and do some work [%s]', time.ctime()) time.sleep(4) #这是整个程序的结束， def main(): readis_ready= threading.Event() #flag = Flase #name:有默认的名称，可以进行更改它的线程名 t1 = threading.Thread(target=worker,args=(readis_ready,),name='t1')#实例化对象，函数名、实参、更改线程名， t1.start() #运行 t2 = threading.Thread(target=worker, args=(readis_ready,), name='t2') t2.start() logging.debug('first of all, check redis server, make sure it is OK, and then trigger the redis ready event') time.sleep(6) #设置event的状态值为True,所有阻塞池的线程就会激活，等待操作系统调度 readis_ready.set() #flag = Ture ''' event:重点 event.isSet()：返回event的状态值； event.wait()：如果 event.isSet()==False将阻塞线程； event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度； event.clear()：恢复event的状态值为False。 每个线程都是不可控的，所以需要用到一个标志位进行流程控制，在main（）代码运行的时候当标志位为True的时候就可以去运行worker（）代码的流程 ''' if __name__ == '__main__': main()
threading.Event的wait方法还接受一个超时参数，默认情况下如果事件一致没有发生，wait方法会一直阻塞下去，而加入这个超时参数之后，如果阻塞时间超过这个参数设定的值之后，wait方法会返回。对应于上面的应用场景，如果Redis服务器一致没有启动，我们希望子线程能够打印一些日志来不断地提醒我们当前没有一个可以连接的Redis服务，我们就可以通过设置这个超时参数来达成这样的目的：
Semaphore（信号量）
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：
#!/usr/bin/python # -*- coding: UTF-8 -*- import threading import time #信号量，一次打印5个，并行 #关键字threading.Semaphore(5) semaphore = threading.Semaphore(5) def func(): if semaphore.acquire():#计数器每次-1 print(threading.currentThread().getName()+' get semaphore') time.sleep(2) semaphore.release()#计数器每次进行+1 for i in range(20): t1 = threading.Thread(target=func) t1.start()
应用：连接池
队列(queue)
queue方法
创建一个“队列”对象 import Queue q = Queue.Queue(maxsize = 10) Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。 将一个值放入队列中 q.put(10) 调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为 1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。 将一个值从队列中取出 q.get() 调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True， get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。 Python Queue模块有三种队列及构造函数: 1、Python Queue模块的FIFO队列先进先出。 class queue.Queue(maxsize) 2、LIFO类似于堆，即先进后出。 class queue.LifoQueue(maxsize) 3、还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize) 此包中的常用方法(q = Queue.Queue()): q.qsize() 返回队列的大小 q.empty() 如果队列为空，返回True,反之False q.full() 如果队列满了，返回True,反之False q.full 与 maxsize 大小对应 q.get([block[, timeout]]) 获取队列，timeout等待时间 q.get_nowait() 相当q.get(False) 非阻塞 q.put(item) 写入队列，timeout等待时间 q.put_nowait(item) 相当q.put(item, False) q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号 q.join() 实际上意味着等到队列为空，再执行别的操作
join与task_done方法
''' join() 阻塞进程，直到所有任务完成，需要配合另一个方法task_done。 def join(self): with self.all_tasks_done: while self.unfinished_tasks: self.all_tasks_done.wait() task_done() 表示某个任务完成。每一条get语句后需要一条task_done。 import queue q = queue.Queue(5) q.put(10) q.put(20) print(q.get()) q.task_done() print(q.get()) q.task_done() q.join() print("ending!") '''
应用 生产者消费者模型：
为什么要使用生产者和消费者模式
在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
什么是生产者消费者模式
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
这就像，在餐厅，厨师做好菜，不需要直接和客户交流，而是交给前台，而客户去饭菜也不需要不找厨师，直接去前台领取即可，这也是一个结耦的过程。
import time,random import queue,threading q = queue.Queue() def Producer(name): count = 0 while count <10: print("making........") time.sleep(random.randrange(3)) q.put(count) print('Producer %s has produced %s baozi..' %(name, count)) count +=1 #q.task_done() #q.join() print("ok......") def Consumer(name): count = 0 while count <10: time.sleep(random.randrange(4)) if not q.empty(): data = q.get() #q.task_done() #q.join() print(data) print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data)) else: print("-----no baozi anymore----") count +=1 p1 = threading.Thread(target=Producer, args=('A',)) c1 = threading.Thread(target=Consumer, args=('B',)) # c2 = threading.Thread(target=Consumer, args=('C',)) # c3 = threading.Thread(target=Consumer, args=('D',)) p1.start() c1.start() # c2.start() # c3.start()
multiprocessing模块
由于GIL的存在，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。
multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。
python的进程调用
# Process类调用 from multiprocessing import Process import time def f(name): print('hello', name,time.ctime()) time.sleep(1) if __name__ == '__main__': p_list=[] for i in range(3): p = Process(target=f, args=('alvin:%s'%i,)) p_list.append(p) p.start() for i in p_list: p.join() print('end') # 继承Process类调用 from multiprocessing import Process import time class MyProcess(Process): def __init__(self): super(MyProcess, self).__init__() # self.name = name def run(self): print ('hello', self.name,time.ctime()) time.sleep(1) if __name__ == '__main__': p_list=[] for i in range(3): p = MyProcess() p.start() p_list.append(p) for p in p_list: p.join() print('end')
process类
构造方法：
Process([group [, target [, name [, args [, kwargs]]]]])
group: 线程组，目前还没有实现，库引用中提示必须是None；
target: 要执行的方法；
name: 进程名；
args/kwargs: 要传入方法的参数。
实例方法：
is_alive()：返回进程是否在运行。
join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。
start()：进程准备就绪，等待CPU调度
run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。
terminate()：不管任务是否完成，立即停止工作进程
属性：
daemon：和线程的setDeamon功能一样
name：进程名字。
pid：进程号。
from multiprocessing import Process import os import time def info(name): print("name:",name) print('parent process:', os.getppid()) print('process id:', os.getpid()) print("------------------") time.sleep(1) def foo(name): info(name) if __name__ == '__main__': info('main process line') p1 = Process(target=info, args=('alvin',)) p2 = Process(target=foo, args=('egon',)) p1.start() p2.start() p1.join() p2.join() print("ending")
通过tasklist(Win)或者ps -elf |grep(linux)命令检测每一个进程号(PID)对应的进程名
协程
yield与协程
import time """ 传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。 如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。 """ # 注意到consumer函数是一个generator（生成器）: # 任何包含yield关键字的函数都会自动成为生成器(generator)对象 def consumer(): r = '' while True: # 3、consumer通过yield拿到消息，处理，又通过yield把结果传回； # yield指令具有return关键字的作用。然后函数的堆栈会自动冻结(freeze)在这一行。 # 当函数调用者的下一次利用next()或generator.send()或for-in来再次调用该函数时， # 就会从yield代码的下一行开始，继续执行，再返回下一次迭代结果。通过这种方式，迭代器可以实现无限序列和惰性求值。 n = yield r if not n: return print('[CONSUMER] ←← Consuming %s...' % n) time.sleep(1) r = '200 OK' def produce(c): # 1、首先调用c.next()启动生成器 next(c) n = 0 while n < 5: n = n + 1 print('[PRODUCER] →→ Producing %s...' % n) # 2、然后，一旦生产了东西，通过c.send(n)切换到consumer执行； cr = c.send(n) # 4、produce拿到consumer处理的结果，继续生产下一条消息； print('[PRODUCER] Consumer return: %s' % cr) # 5、produce决定不生产了，通过c.close()关闭consumer，整个过程结束。 c.close() if __name__=='__main__': # 6、整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。 c = consumer() produce(c) ''' result: [PRODUCER] →→ Producing 1... [CONSUMER] ←← Consuming 1... [PRODUCER] Consumer return: 200 OK [PRODUCER] →→ Producing 2... [CONSUMER] ←← Consuming 2... [PRODUCER] Consumer return: 200 OK [PRODUCER] →→ Producing 3... [CONSUMER] ←← Consuming 3... [PRODUCER] Consumer return: 200 OK [PRODUCER] →→ Producing 4... [CONSUMER] ←← Consuming 4... [PRODUCER] Consumer return: 200 OK [PRODUCER] →→ Producing 5... [CONSUMER] ←← Consuming 5... [PRODUCER] Consumer return: 200 OK '''
greentlet
greelet机制的主要思想是：生成器函数或者协程函数中的yield语句挂起函数的执行，直到稍后使用next()或send()操作进行恢复为止。可以使用一个调度器循环在一组生成器函数之间协作多个任务。greentlet是python中实现我们所谓的"Coroutine(协程)"的一个基础库.
from greenlet import greenlet def test1(): print (12) gr2.switch() print (34) gr2.switch() def test2(): print (56) gr1.switch() print (78) gr1 = greenlet(test1) gr2 = greenlet(test2) gr1.switch()
基于greenlet的框架
gevent模块实现协程
Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。
gevent是第三方库，通过greenlet实现协程，其基本思想是：
当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。
由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成：
import gevent import time def foo(): print("running in foo") gevent.sleep(2) print("switch to foo again") def bar(): print("switch to bar") gevent.sleep(5) print("switch to bar again") start=time.time() gevent.joinall( [gevent.spawn(foo), gevent.spawn(bar)] ) print(time.time()-start)
当然，实际代码里，我们不会用gevent.sleep()去切换协程，而是在执行到IO操作时，gevent自动切换，代码如下：
from gevent import monkey monkey.patch_all() import gevent from urllib import request import time def f(url): print('GET: %s' % url) resp = request.urlopen(url) data = resp.read() print('%d bytes received from %s.' % (len(data), url)) start=time.time() gevent.joinall([ gevent.spawn(f, 'https://itk.org/'), gevent.spawn(f, 'https://www.github.com/'), gevent.spawn(f, 'https://zhihu.com/'), ]) # f('https://itk.org/') # f('https://www.github.com/') # f('https://zhihu.com/') print(time.time()-start)
扩展：
gevent是一个基于协程（coroutine）的Python网络函数库，通过使用greenlet提供了一个在libev事件循环顶部的高级别并发API。
主要特性有以下几点：
<1> 基于libev的快速事件循环，Linux上面的是epoll机制
<2> 基于greenlet的轻量级执行单元
<3> API复用了Python标准库里的内容
<4> 支持SSL的协作式sockets
<5> 可通过线程池或c-ares实现DNS查询
<6> 通过monkey patching功能来使得第三方模块变成协作式
gevent.spawn()方法spawn一些jobs，然后通过gevent.joinall将jobs加入到微线程执行队列中等待其完成，设置超时为2秒。执行后的结果通过检查gevent.Greenlet.value值来收集。
1、关于Linux的epoll机制： epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的 增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。epoll的优点： （1）支持一个进程打开大数目的socket描述符。select的一个进程所打开的FD由FD_SETSIZE的设置来限定，而epoll没有这个限制，它所支持的FD上限是 最大可打开文件的数目，远大于2048。 （2）IO效率不随FD数目增加而线性下降：由于epoll只会对“活跃”的socket进行操作，于是，只有”活跃”的socket才会主动去调用 callback函数，其他 idle状态的socket则不会。 （3）使用mmap加速内核与用户空间的消息传递。epoll是通过内核于用户空间mmap同一块内存实现的。 （4）内核微调。 2、libev机制 提供了指定文件描述符事件发生时调用回调函数的机制。libev是一个事件循环器：向libev注册感兴趣的事件，比如socket可读事件，libev会对所注册的事件 的源进行管理，并在事件发生时触发相应的程序。 ps
浙公网安备 33010602011771号