复习操作系统：
操作系统 ：
位于底层硬件与应用系统之间的一层
向下操作硬件 向上为软件提供接口
无操作系统---------》批处理-----------》分时操作系统：多个联机终端+多道技术
处理来自多个程序发起的多个（多个即多路）共享（共享即复用）资源的请求，简称多路复用
多路复用有两种实现方式
1.时间上的复用
2.空间上的复用
http://www.cnblogs.com/liuguniang/p/6544854.html
操作系统什么时候触发切换：
1 出现io操作
2 固定时间(操作系统自动)
进程与线程的概念
进程的定义：
进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进
程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执
行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。
想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(cpu)，而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他离开时的那一步继续做下去。
线程出现的原因：
线程的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，使到进程内并发成为可能。
多个进程同时处理一个资源的情况下，切换时间较长，所以出现了线程的概念
多个线程共享一个进程的资源，对资源进行操作，切换效率较高
线程的定义：
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同
组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。
假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。是的，这种机制就是线程。
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。
线程与进程的区别：
进程 资源管理单位 （容器）CPU调度和分派的基本单位
线程 最小执行单位
进程和线程的关系：
1 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程
2 资源分配给线程，同一进程的所有线程共享该进程的所有资源
3 CPU分给线程，即真正在CPU上是线程
串行，并发和并行
并发与并行的区别：
并发 单核的情况下 由于高速切换 看似同时执行多个功能（进程）
并发处理(concurrency Processing)：指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个
处理机(CPU)上运行，但任一个时刻点上只有一个程序在处理机(CPU)上运行
并行 多核的情况下 多个线程同时执行
并行处理（Parallel Processing）是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程
序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。
并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说，并行是并发的子集
同步和异步
在计算机领域，同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。举个例子，打电话时就是同步通信，发短息时就是异步通信。
GIL锁
Python中的线程是操作系统的原生线程，Python虚拟机使用一个全局解释器锁（Global Interpreter Lock）来互斥线程对Python虚拟机的使用。
为了支持多线程机制，一个基本的要求就是需要实现不同线程对共享资源访问的互斥，所以引入了GIL。
GIL：在一个线程拥有了解释器的访问权之后，其他的所有线程都必须等待它释放解释器的访问权，即使这些线程的下一条指令并不会互相影响。
在调用任何Python C API之前，要先获得GIL
GIL缺点：多处理器退化为单处理器；优点：避免大量的加锁解锁操作
影响：
python 的多线程 ：由于GIL（全局解释器锁），导致同一时刻，同一进程只能有一个线程
原因：若同一时刻并行多个线程，在其中一个线程结束后，垃圾回收机制会回收资源，导致其他线程无法运行，所以有全局解释器锁
global Interpreter lock
加在cpython解释器上
对于计算密集型任务： python的多线程并没有用 因为计算密集的程序会一直占用CPU
对于IO密集型任务：python的多线程是有意义的 爬虫
计算密集型：
1 #*****************************利用多线程 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()
解决方案：
1 # ***************************************利用多进程 2 from multiprocessing import Process 3 import time 4 5 def counter(): 6 i = 0 7 for _ in range(40000000): 8 i = i + 1 9 10 return True 11 12 def main(): 13 14 l=[] 15 start_time = time.time() 16 17 for _ in range(2): 18 t=Process(target=counter) 19 t.start() 20 l.append(t) 21 t.join() #串行 Total time: 4.597262859344482 22 23 for t in l: #多进程 并行 Total time: 2.7161552906036377 24 t.join() 25 26 end_time = time.time() 27 print("Total time: {}".format(end_time - start_time)) 28 29 if __name__ == '__main__': 30 main()
用multiprocessing替代Thread multiprocessing库的出现很大程度上是为了弥补thread库因为GIL而低效的缺陷。它完整的复制了一套thread所提供的接口方便迁移。唯一的不同就是它使用了多进程而不是多线程。每个进程有自己的独立的GIL，因此也不会出现进程之间的GIL争抢。 当然multiprocessing也不是万能良药。它的引入会增加程序实现时线程间数据通讯和同步的困难。就拿计数器来举例子，如果我们要多个线程累加同一个变量，对于thread来说，申明一个global变量，用thread.Lock的context包裹住三行就搞定了。而multiprocessing由于进程之间无法看到对方的数据，只能通过在主线程申明一个Queue，put再get或者用share memory的方法。这个额外的实现成本使得本来就非常痛苦的多线程程序编码，变得更加痛苦了。 总结：因为GIL的存在，只有IO Bound场景下得多线程会得到较好的性能 - 如果对并行计算性能较高的程序可以考虑把核心部分换成C模块，或者索性用其他语言实现 - GIL在较长一段时间内将会继续存在，但是会不断对其进行改进。 所以对于GIL，既然不能反抗，那就学会去享受它吧！
线程
实现方式一：
1 #一个进程里面的三个线程实现并发 2 import threading #主线程 3 import time 4 def tingge(): 5 print('听歌') 6 time.sleep(3) 7 print('听课结束') 8 def bog(): 9 print('write bog') 10 time.sleep(3) 11 print('博客结束') 12 print(time.time()-s) #子线程结束之后运行主线程 进程总共运行时间 13 obj = threading.Thread(target=tingge) #线程对象 14 obj1 = threading.Thread(target=bog) #线程对象 15 s = time.time() #两个子线程运行之前的时间 16 obj.start() #子线程1 17 obj1.start() #子线程2 18 19 # obj.join() 20 # obj1.join() #阻塞 子线程完成运行之前，这个子进程的父进程将一直被阻塞 21 # print(time.time() - s) #进程总共运行时间 22 print('结束；；；；；')
实现方式二：
1 class MyThread(threading.Thread): 2 def __init__(self,num): 3 threading.Thread.__init__(self) 4 self.num = num 5 def run(self): 6 print('running on num %s'%self.num) 7 8 t1 = MyThread(56) 9 t2 = MyThread(78) 10 11 t1.start() 12 t2.start() 13 print('ending')
线程的方法：join，setDaemon
1 import threading 2 import time 3 def Music(name): 4 print('begin to listen {name}.{time}'.format(name = name,time = time.ctime())) 5 time.sleep(3) 6 print('end listening {time}'.format(time=time.ctime())) 7 def Blog(title): 8 print('begin to record {title}.{time}'.format(title = title,time = time.ctime())) 9 time.sleep(5) 10 print('end record {time}'.format(time = time.ctime())) 11 12 threads = [] 13 14 t1 = threading.Thread(target=Music,args=('fill me',)) 15 t2 = threading.Thread(target=Blog,args=('python',)) 16 threads.append(t1) 17 threads.append(t2) 18 # 19 if __name__ == '__main__': 20 t1.setDaemon(True) #守护线程 应用：监听 21 t2.setDaemon(True) 22 for t in threads: 23 t.start() 24 t.join() 25 for t in threads: 26 t.join()
同步锁 （互斥锁） 只能加一次锁
锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象
（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：
1 import time 2 import threading 3 4 def sub_num(): 5 global num 6 # num -= 1 7 lock.acquire() #只对公共数据的操作加同步锁 8 temp = num 9 time.sleep(0.1) 10 num = temp -1 11 lock.release() 12 13 num = 100 14 lock = threading.Lock() 15 thread_list = [] 16 17 for i in range(100): 18 t = threading.Thread(target=sub_num) 19 t.start() 20 thread_list.append(t) 21 22 for t in thread_list: 23 t.join() 24 print('result:',num)
死锁
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法
推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
1 import threading 2 import time 3 mutexA = threading.Lock() 4 mutexB = threading.Lock() 5 6 class Mythread(threading.Thread): 7 def __init__(self): 8 threading.Thread.__init__(self) 9 def run(self): 10 self.func1() 11 self.func2() 12 def func1(self): 13 mutexA.acquire() 14 print('i am %s, get res: %s------%s'%(self.name,'RESA',time.time)) 15 mutexB.acquire() 16 print('i am %s, get res: %s------%s' % (self.name, 'RESA', time.time)) 17 mutexB.release() 18 mutexA.release() 19 def func2(self): 20 mutexB.acquire() 21 print('i am %s, get res: %s------%s'%(self.name,'RESA',time.time)) 22 # time.sleep(0.1) 23 mutexA.acquire() 24 print('i am %s, get res: %s------%s' % (self.name, 'RESA', time.time)) 25 mutexA.release() 26 mutexB.release() 27 28 if __name__ == '__main__': 29 print('---------------------') 30 for i in range(10): 31 my_thread = Mythread() 32 my_thread.start()
递归锁：
在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，
counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。
上面的例子如果使用RLock代替Lock，则不会发生死锁：
1 import threading 2 import time 3 mutexA = threading.RLock() 4 5 6 class Mythread(threading.Thread): 7 def __init__(self): 8 threading.Thread.__init__(self) 9 def run(self): 10 self.func1() 11 self.func2() 12 def func1(self): 13 mutexA.acquire() 14 print('i am %s, get res: %s------%s'%(self.name,'RESA',time.time)) 15 mutexA.acquire() 16 print('i am %s, get res: %s------%s' % (self.name, 'RESA', time.time)) 17 mutexA.release() 18 mutexA.release() 19 def func2(self): 20 mutexA.acquire() 21 print('i am %s, get res: %s------%s'%(self.name,'RESA',time.time)) 22 # time.sleep(0.1) 23 mutexA.acquire() 24 print('i am %s, get res: %s------%s' % (self.name, 'RESA', time.time)) 25 mutexA.release() 26 mutexA.release() 27 28 if __name__ == '__main__': 29 print('---------------------') 30 for i in range(10): 31 my_thread = Mythread() 32 my_thread.start()
线程之间的通信 标志位 子线程 ----------子线程 主线程有控制进程关闭的能力
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服务。
1 import threading 2 import time 3 import logging 4 logging.basicConfig(level = logging.DEBUG,format = '%(threadName)s-%(message)s') 5 def worker(n): 6 logging.debug('waiting for redis ready...') 7 while not n.isSet(): 8 logging.debug('waiting...............') 9 n.wait(3) 10 logging.debug('redis ready, and connect to redis server and do some work[%s]',time.ctime()) 11 print(n.isSet()) 12 time.sleep(1) 13 def main(): 14 n = threading.Event() 15 t1 = threading.Thread(target=worker,args = (n,),name = 't1') 16 t1.start() 17 t2 = threading.Thread(target=worker,args = (n,),name = 't2') 18 t2.start() 19 logging.debug('first of all,check redis server,make sure it is ok,and trigger the redis ready event') 20 time.sleep(3) 21 n.set() 22 if __name__ == '__main__': 23 main()
threading.Event的wait方法还接受一个超时参数，默认情况下如果事件一致没有发生，wait方法会一直阻塞下去，而加入这个超时参数之后，如果阻塞时间超过这个参数设定的值之后，wait方法会返回。对应于上面的应用场景，如果Redis服务器一致没有启动，我们希望子线程能够打印一些日志来不断地提醒我们当前没有一个可以连接的Redis服务，我们就可以通过设置这个超时参数来达成这样的目的
Semaphore 信号量 设置竞争同一把锁的线程的数量 应用： 数据库的连接池
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：
1 import threading 2 import time 3 semaphore = threading.Semaphore(5) 4 5 def func(): 6 if semaphore.acquire(): 7 print(threading.currentThread().getName() + 'get semaphore') 8 time.sleep(2) 9 semaphore.release() 10 for i in range(20): 11 t = threading.Thread(target=func) 12 t.start()
队列
put 和 get 方法：
创建一个“队列”对象 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异常。
task_done 和 join 方法
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!")
此包中的常用方法(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() 实际上意味着等到队列为空，再执行别的操作
Python Queue模块有三种队列及构造函数: 1、Python Queue模块的FIFO队列先进先出。 class queue.Queue(maxsize) 2、LIFO类似于堆，即先进后出。 class queue.LifoQueue(maxsize) 3、还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize) import queue #先进后出 q=queue.LifoQueue() q.put(34) q.put(56) q.put(12) #优先级 q=queue.PriorityQueue() q.put([5,100]) q.put([7,200]) q.put([3,"hello"]) q.put([4,{"name":"alex"}]) while 1: data=q.get() print(data)
在线程中的应用：
多线程的情况下，对于公共数据不做复杂的加锁，而采用队列来存储数据，提高线程间资源的安全性
应用：生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来
进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，
阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
1 import time,random 2 import queue,threading 3 4 q = queue.Queue() 5 6 def Producer(name): 7 count = 0 8 while count <3: 9 # print("making........") 10 time.sleep(3) 11 q.put(count) 12 print('Producer %s has produced %s baozi..' %(name, count)) 13 count +=1 14 # q.task_done() 15 # q.join() 16 # print("ok......") 17 def Consumer(name): 18 count = 0 19 while count <3: 20 time.sleep(1) 21 if not q.empty(): 22 data = q.get() 23 # q.task_done() 24 # q.join() 25 print(data) 26 print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data)) 27 # else: 28 # print("-----no baozi anymore----") 29 count +=1 30 31 p1 = threading.Thread(target=Producer, args=('A',)) 32 c1 = threading.Thread(target=Consumer, args=('B',)) 33 # c2 = threading.Thread(target=Consumer, args=('C',)) 34 # c3 = threading.Thread(target=Consumer, args=('D',)) 35 p1.start() 36 c1.start() 37 # c2.start() 38 # c3.start()
基于队列实现一个生产者消费者模型，要求：队列内元素不能超过5个，一旦有五个元素了，生产者不再生产
1 import queue,time 2 q = queue.Queue() 3 4 import threading 5 6 def Producer(name): 7 i = 0 8 while True: 9 if q.qsize()<5: 10 time.sleep(1) 11 q.put(i) 12 print('生产者%s 生产了第%s 个包子'%(name,i)) 13 i += 1 14 15 def Consumer(name): 16 while True: 17 time.sleep(1) 18 if not q.empty(): 19 data = q.get() 20 print('消费者%s 消费了第%s 个包子'%(name,data)) 21 else: 22 print('没有包子被生产出来') 23 24 p1 = threading.Thread(target=Producer,args = ('A',)) 25 c1 = threading.Thread(target=Consumer,args=('B',)) 26 27 p1.start() 28 c1.start()
应用场景：比如同时有很多个客户端访问服务端，但是内存有限，就可以设置内存中最多可以有5个客户端进来，内存对之进行处理，只要内存缓存中的客户端数量少于5个，客户端就可以一直可以进入服务端内存缓存。
进程
实现方式一：
1 from multiprocessing import Process 2 import time 3 4 def f(name): 5 print('hello',name,time.ctime()) 6 time.sleep(1) 7 8 if __name__ == '__main__': 9 p_list = [] 10 for i in range(3): 11 p = Process(target=f,args = ('alvin:%s'%i,)) 12 p_list.append(p) 13 p.start() 14 for i in p_list: 15 p.join() 16 print('end')
实现方式二：
1 class Myprocess(Process): 2 def __init__(self): 3 super().__init__() 4 def run(self): 5 print('hello',self.name,time.ctime()) 6 time.sleep(1) 7 if __name__ == '__main__': 8 p_list = [] 9 for i in range(3): 10 p = Myprocess() 11 p.start() #调用类的run方法 12 p_list.append(p) 13 for p in p_list: 14 p.join() 15 print('end')
进程的方法：
1 from multiprocessing import Process 2 import os 3 import time 4 def info(name): #打印进程对象的属性 5 print("name:",name) 6 print('parent process:', os.getppid()) 7 print('process id:', os.getpid()) 8 print("------------------") 9 time.sleep(1) 10 11 def foo(name): 12 info(name) 13 14 if __name__ == '__main__': 15 16 info('main process line') 17 18 p1 = Process(target=info, args=('alvin',)) #设置进程要执行的方法和进程名 19 p1.daemon(True) 20 p2 = Process(target=foo, args=('egon',)) 21 p1.start() 22 p2.start() 23 24 p1.join() 25 p2.join() 26 27 print("ending")
构造方法：
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：进程号。
协程
协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程。
协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：
协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。
传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。 如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。
1 # 利用yield 实现协程 手动切换 2 import time 3 def consumer(): #生成器函数 4 r = '' 5 while True: 6 n = yield r 7 if not n: 8 return 9 print('[consumer] consuming %s...'%n) 10 time.sleep(1) 11 r = '200 ok' 12 def product(c): #将生成器传入 13 c.__next__() 14 n = 0 15 while n < 5 : 16 n = n +1 17 print('[product] producting %s'%n) 18 cr = c.send(n) 19 print('consumer return %s'%cr) 20 c.close() 21 if __name__ == '__main__': 22 c = consumer() 23 product(c)
greentlet是python中实现我们所谓的"Coroutine(协程)"的一个基础库.
1 from greenlet import greenlet 2 3 4 def test1(): 5 print(12) 6 gr2.switch() #手动切换 7 print(34) 8 gr2.switch() 9 10 11 def test2(): 12 print(56) 13 gr1.switch() 14 print(78) 15 16 17 gr1 = greenlet(test1) 18 gr2 = greenlet(test2) 19 gr1.switch()
gevent是第三方库，通过greenlet实现协程，其基本思想是：
当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。
由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。
1 import gevent 2 import time 3 4 def foo(): 5 print("running in foo") 6 gevent.sleep(2) #模拟IO操作 自动切换 7 print("switch to foo again") 8 9 def bar(): 10 print("switch to bar") 11 gevent.sleep(5) #模拟IO操作 12 print("switch to bar again") 13 14 start=time.time() 15 16 gevent.joinall( 17 [gevent.spawn(foo), 18 gevent.spawn(bar)] 19 ) 20 21 print(time.time()-start)
实际代码里，我们不会用gevent.sleep()去切换协程，而是在执行到IO操作时，gevent自动切换，代码如下：
由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成
1 from gevent import monkey 2 monkey.patch_all() 3 4 import gevent 5 from urllib import request 6 import time 7 8 def f(url): 9 print('get : %s'%url) 10 resp = request.urlopen(url) 11 data = resp.read() 12 print('%d bytes received from %s'%(len(data),url)) 13 14 start = time.time() 15 gevent.joinall([ 16 gevent.spawn(f,'http://itk.org/'), 17 gevent.spawn(f,'https://www.github.com/'), 18 gevent.spawn(f, 'https://zhihu.com/'), 19 ]) 20 21 print(time.time()-start)
协程的好处：
无需线程上下文切换的开销
无需原子操作锁定及同步的开销
方便切换控制流，简化编程模型
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
缺点：
无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序
扫一扫
1976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
