详解python线程，进程，协程

骑猪看日落 2024-04-17 06:01 87阅读 0赞

### 文章目录 ###

*  线程
 *   *  基本概念
     *  创建线程
     *  多线程共享变量问题
     *   *  锁
         *  死锁
 *  进程
 *   *  进程以及状态
     *   *  进程
         *  进程的状态
     *  进程的创建-multiprocessing
     *   *  Process语法结构如下
         *  创建process
         *  进程之间不共享全局变量
     *  进程和线程的区别
     *  进程间通信-Queue
     *   *  Queue的使用
     *  进程池Pool
 *  协程
 *   *  迭代器
     *   *  1. 可迭代对象
         *  2. 如何判断一个对象是否可以迭代
         *  3. 可迭代对象的本质
         *  4. iter()函数与next()函数
         *  5. 如何判断一个对象是否是迭代器
         *  6. 迭代器Iterator
         *  7. 迭代器的应用场景
     *  生成器
     *   *  1. 生成器
         *  协程
         *  协程是啥
         *  简单实现协程yield实现
         *  greenlet实现
         *  gevent实现
 *  进程、线程、协程对比
 *   *  总结

# 线程 #

## 基本概念 ##

*  **多任务**: 操作系统可以同时运行多个任务
 *  **并发**:某一时刻只有一个任务执行,某段时间多个任务交替执行,cup数<核心数>
 *  **并行**:某一时刻有多个任务同时执行,cpu核心数>任务数
 *  **线程**:是操作系统能够进行运算调度的最小单位。一条线程指的是进程中一个单一顺序的控制流,简单的理解就是

## 创建线程 ##

1.python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

#coding=utf-8
    import threading
    import time
    
    def saySorry():
        print("你好？")
        time.sleep(1)
    
    if __name__ == "__main__":
        for i in range(5):
            t = threading.Thread(target=saySorry)
            t.start() #启动线程，即让线程开始执行

在一秒钟会输出很多次你好

2.主线程会等待所有的子线程结束后才结束

#coding=utf-8
    import threading
    from time import sleep,ctime
    
    def sing():
        for i in range(3):
            print("正在唱歌...%d"%i)
            sleep(1)
    
    def dance():
        for i in range(3):
            print("正在跳舞...%d"%i)
            sleep(1)
    
    if __name__ == '__main__':
        print('---开始---:%s'%ctime())
    
        t1 = threading.Thread(target=sing)
        t2 = threading.Thread(target=dance)
    
        t1.start()
        t2.start()
    
        #sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
        print('---结束---:%s'%ctime())

![在这里插入图片描述][20190825204315180.gif]

1.  查看线程数量

length = len(threading.enumerate())
      threading.enumerate() 当前存在的线程名的元组

4,继承thread类  
通过使用threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法.**适合于一个线程里的任务比较复杂,需要多个方法一起完成**

#coding=utf-8
    import threading
    import time
    
    class MyThread(threading.Thread):
        def run(self):
            for i in range(3):
                time.sleep(1)
                msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
                print(msg)
    
    
    if __name__ == '__main__':
        t = MyThread()
        t.start()

**注意**

> python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程

> 多线程程序的执行顺序是不确定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

**总结**

> 每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。  
> 当线程的run()方法结束时该线程完成。 无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

## 多线程共享变量问题 ##

假设两个线程t1和t2都要对全局变量g\_num(默认是0)进行加1运算，t1和t2都各对g\_num加10次，g\_num的最终的结果应该为20。

但是由于是多线程同时操作，有可能出现下面情况：

在g\_num=0时，t1取得g\_num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得g\_num=0  
然后t2对得到的值进行加1并赋给g\_num，使得g\_num=1  
然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g\_num。  
这样导致虽然t1和t2都对g\_num加1，但结果仍然是g\_num=1

import threading
        import time
        
        g_num = 0
        
        def work1(num):
            global g_num
            for i in range(num):
                g_num += 1
            print("----in work1, g_num is %d---"%g_num)
        
        
        def work2(num):
            global g_num
            for i in range(num):
                g_num += 1
            print("----in work2, g_num is %d---"%g_num)
        
        
        print("---线程创建之前g_num is %d---"%g_num)
        
        t1 = threading.Thread(target=work1, args=(1000000,))
        t1.start()
        
        t2 = threading.Thread(target=work2, args=(1000000,))
        t2.start()
        
        while len(threading.enumerate()) != 1:
            time.sleep(1)
        
        print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

运行结果：

---线程创建之前g_num is 0---
    ----in work1, g_num is 1088005---
    ----in work2, g_num is 1286202---
    2个线程对同一个全局变量操作之后的最终结果是:1286202

### 锁 ###

对于上面的问题，可以通过线程同步来进行解决

思路，如下:

> 系统调用t1，然后获取到g\_num的值为0，此时上一把锁，即不允许其他线程操作g\_num t1对g\_num的值进行+1  
> t1解锁，此时g\_num的值为1，其他的线程就可以使用g\_num了，而且是g\_num的值不是0而是1  
> 同理其他线程在对g\_num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入**互斥锁。**

互斥锁为资源引入一个状态：锁定/非锁定

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

**threading模块中定义了Lock类，可以方便的处理锁定**：

> 创建锁 mutex = threading.Lock()
> 
> 锁定 mutex.acquire()
> 
> \#释放 mutex.release()

**注意：**  
如果这个锁之前是没有上锁的，那么acquire不会堵塞  
如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁

使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import threading
        import time
        
        g_num = 0
        
        def test1(num):
            global g_num
            for i in range(num):
                mutex.acquire()  # 上锁
                g_num += 1
                mutex.release()  # 解锁
        
            print("---test1---g_num=%d"%g_num)
        
        def test2(num):
            global g_num
            for i in range(num):
                mutex.acquire()  # 上锁
                g_num += 1
                mutex.release()  # 解锁
        
            print("---test2---g_num=%d"%g_num)
        
        # 创建一个互斥锁
        # 默认是未上锁的状态
        mutex = threading.Lock()
        
        # 创建2个线程，让他们各自对g_num加1000000次
        p1 = threading.Thread(target=test1, args=(1000000,))
        p1.start()
        
        p2 = threading.Thread(target=test2, args=(1000000,))
        p2.start()
        
        # 等待计算完成
        while len(threading.enumerate()) != 1:
            time.sleep(1)
        
        print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

运行结果：

---test1---g_num=1909909
    ---test2---g_num=2000000
    2个线程对同一个全局变量操作之后的最终结果是:2000000

### 死锁 ###

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。就好比一对男女朋友吵架后，都在等着对方先道歉，这样最后就分手了。下面是一个死锁的例子

#coding=utf-8
    import threading
    import time
    
    class MyThread1(threading.Thread):
        def run(self):
            # 对mutexA上锁
            mutexA.acquire()
    
            # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
            print(self.name+'----do1---up----')
            time.sleep(1)
    
            # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
            mutexB.acquire()
            print(self.name+'----do1---down----')
            mutexB.release()
    
            # 对mutexA解锁
            mutexA.release()
    
    class MyThread2(threading.Thread):
        def run(self):
            # 对mutexB上锁
            mutexB.acquire()
    
            # mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
            print(self.name+'----do2---up----')
            time.sleep(1)
    
            # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
            mutexA.acquire()
            print(self.name+'----do2---down----')
            mutexA.release()
    
            # 对mutexB解锁
            mutexB.release()
    
    mutexA = threading.Lock()
    mutexB = threading.Lock()
    
    if __name__ == '__main__':
        t1 = MyThread1()
        t2 = MyThread2()
        t1.start()
        t2.start()

运行结果  
![在这里插入图片描述][20190901205449467.png]  
之后程序就一直卡在这。。。解决办法就是避免在上锁和解锁过程中再获取别的锁，这样容易发生嵌套，导致死锁

# 进程 #

## 进程以及状态 ##

### 进程 ###

**程序**：例如xxx.py这是段可执行的代码就是一个程序，它是一个静态的

**进程**：一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元。

**不仅线程完成多任务，进程也是可以的**

### 进程的状态 ###

工作中，任务数往往大于cpu的核数，即一定有一些任务正在执行，而另外一些任务在等待cpu进行执行，因此导致了有了不同的状态  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70]  
**就绪态**：运行的条件都已经充分，正在等在cpu执行  
**执行态**：cpu正在执行其功能  
**等待态**：等待某些条件满足，例如一个程序sleep了，此时就处于等待态

## 进程的创建-multiprocessing ##

multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情

例如个while循环一起执行

# -*- coding:utf-8 -*-
    from multiprocessing import Process
    import time
    
    
    def run_proc():
        """子进程要执行的代码"""
        while True:
            print("----2----")
            time.sleep(1)
    
    
    if __name__=='__main__':
        p = Process(target=run_proc)
        p.start()
        while True:
            print("----1----")
            time.sleep(1)

说明  
创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动

2,获取PID(进程号）

# -*- coding:utf-8 -*-
    from multiprocessing import Process
    import os
    import time
    
    def run_proc():
        """子进程要执行的代码"""
        print('子进程运行中，pid=%d...' % os.getpid())  # os.getpid获取当前进程的进程号
        print('子进程将要结束...')
    
    if __name__ == '__main__':
        print('父进程pid: %d' % os.getpid())  # os.getpid获取当前进程的进程号
        p = Process(target=run_proc)
        p.start()

### Process语法结构如下 ###

Process([group [, target [, name [, args [, kwargs]]]]])

target：如果传递了函数的引用，可以任务这个子进程就执行这里的代码  
args：给target指定的函数传递的参数，以元组的方式传递  
kwargs：给target指定的函数传递命名参数  
name：给进程设定一个名字，可以不设定  
group：指定进程组，大多数情况下用不到  
Process创建的实例对象的常用方法：

start()：启动子进程实例（创建子进程）  
is\_alive()：判断进程子进程是否还在活着  
join(\[timeout\])：是否等待子进程执行结束，或等待多少秒  
terminate()：不管任务是否完成，立即终止子进程  
Process创建的实例对象的常用属性：

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数  
pid：当前进程的pid（进程号）

### 创建process ###

# -*- coding:utf-8 -*-
    from multiprocessing import Process
    import os
    from time import sleep
    
    
    def run_proc(name, age, **kwargs):
        for i in range(10):
            print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
            print(kwargs)
            sleep(0.2)
    
    if __name__=='__main__':
        p = Process(target=run_proc, args=('test',18), kwargs={ "m":20})
        p.start()
        sleep(1)  # 1秒中之后，立即结束子进程
        p.terminate()
        p.join()

运行结果:

子进程运行中，name= test,age=18 ,pid=45097...
    {'m': 20}
    子进程运行中，name= test,age=18 ,pid=45097...
    {'m': 20}
    子进程运行中，name= test,age=18 ,pid=45097...
    {'m': 20}
    子进程运行中，name= test,age=18 ,pid=45097...
    {'m': 20}
    子进程运行中，name= test,age=18 ,pid=45097...
    {'m': 20}

### 进程之间不共享全局变量 ###

python中进程之间默认是不能共享全局变量的(子进程不能改变主进程中全局变量的值)

# -*- coding:utf-8 -*-
    from multiprocessing import Process
    import os
    import time
    
    nums = [11, 22]
    
    def work1():
        """子进程要执行的代码"""
        print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
        for i in range(3):
            nums.append(i)
            time.sleep(1)
            print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    
    def work2():
        """子进程要执行的代码"""
        print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
    
    if __name__ == '__main__':
        p1 = Process(target=work1)
        p1.start()
        p1.join()
    
        p2 = Process(target=work2)
        p2.start()

运行结果:

in process1 pid=11349 ,nums=[11, 22]
    in process1 pid=11349 ,nums=[11, 22, 0]
    in process1 pid=11349 ,nums=[11, 22, 0, 1]
    in process1 pid=11349 ,nums=[11, 22, 0, 1, 2]
    in process2 pid=11350 ,nums=[11, 22]

## 进程和线程的区别 ##

>  *  进程是系统进行资源分配和调度的一个独立单位.
>  *  线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

>  *  一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
>  *  进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率 线程不能够独立执行，必须依存在进程中
>  *  可以将进程理解为工厂中的一条流水线，而其中的线程就是这个流水线上的工人 优缺点
>  *  线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。  
>     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 1]

## 进程间通信-Queue ##

Process之间因为不能共享全局变量，需要通信的时候，操作系统提供了很多机制来实现进程间的通信。

### Queue的使用 ###

可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序，首先用一个小实例来演示一下Queue的工作原理：

#coding=utf-8
    from multiprocessing import Queue
    q=Queue(3) #初始化一个Queue对象，最多可接收三条put消息
    q.put("消息1") 
    q.put("消息2")
    print(q.full())  #False
    q.put("消息3")
    print(q.full()) #True
    
    #因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
    try:
        q.put("消息4",True,2)
    except:
        print("消息列队已满，现有消息数量:%s"%q.qsize())
    
    try:
        q.put_nowait("消息4")
    except:
        print("消息列队已满，现有消息数量:%s"%q.qsize())
    
    #推荐的方式，先判断消息列队是否已满，再写入
    if not q.full():
        q.put_nowait("消息4")
    
    #读取消息时，先判断消息列队是否为空，再读取
    if not q.empty():
        for i in range(q.qsize()):
            print(q.get_nowait())

运行结果:

False  
True  
消息列队已满，现有消息数量:3  
消息列队已满，现有消息数量:3  
消息1  
消息2  
消息3

**说明**

*  初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；
 *  Queue.qsize()：返回当前队列包含的消息数量；
 *  Queue.empty()：如果队列为空，返回True，反之False ；
 *  Queue.full()：如果队列满了，返回True,反之False；
 *  Queue.get(\[block\[, timeout\]\])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；

2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

Queue.get\_nowait()：相当Queue.get(False)；

Queue.put(item,\[block\[, timeout\]\])：将item消息写入队列，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；

2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

Queue.put\_nowait(item)：相当Queue.put(item, False)；

实例

def write(q):
        for value in ['A', 'B', 'C']:
            print('Put %s to queue...' % value)
            q.put(value)
            time.sleep(random.random())
            
    #读数据进程执行的代码:
    def read(q):
        while True:
            if not q.empty():
                value = q.get(True)
                print('Get %s from queue.' % value)
                time.sleep(random.random())
            else:
                break
    
    if __name__=='__main__':
        # 父进程创建Queue，并传给各个子进程：
        q = Queue()
        pw = Process(target=write, args=(q,))
        pr = Process(target=read, args=(q,))
        # 启动子进程pw，写入:
        pw.start()    
        # 等待pw结束:
        pw.join()
        # 启动子进程pr，读取:
        pr.start()
        pr.join()
        # pr进程里是死循环，无法等待其结束，只能强行终止:
        print('')
        print('所有数据都写入并且读完')

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 2]

## 进程池Pool ##

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务.

# -*- coding:utf-8 -*-
    from multiprocessing import Pool
    import os, time, random
    
    def worker(msg):
        t_start = time.time()
        print("%s开始执行,进程号为%d" % (msg,os.getpid()))
        # random.random()随机生成0~1之间的浮点数
        time.sleep(random.random()*2) 
        t_stop = time.time()
        print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))
    
    po = Pool(3)  # 定义一个进程池，最大进程数3
    for i in range(0,10):
        # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
        # 每次循环将会用空闲出来的子进程去调用目标
        po.apply_async(worker,(i,))
    
    print("----start----")
    po.close()  # 关闭进程池，关闭后po不再接收新的请求
    po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
    print("-----end-----")

运行结果:

----start----
    0开始执行,进程号为21466
    1开始执行,进程号为21468
    2开始执行,进程号为21467
    0 执行完毕，耗时1.01
    3开始执行,进程号为21466
    2 执行完毕，耗时1.24
    4开始执行,进程号为21467
    3 执行完毕，耗时0.56
    5开始执行,进程号为21466
    1 执行完毕，耗时1.68
    6开始执行,进程号为21468
    4 执行完毕，耗时0.67
    7开始执行,进程号为21467
    5 执行完毕，耗时0.83
    8开始执行,进程号为21466
    6 执行完毕，耗时0.75
    9开始执行,进程号为21468
    7 执行完毕，耗时1.03
    8 执行完毕，耗时1.05
    9 执行完毕，耗时1.69
    -----end-----

**multiprocessing.Pool常用函数解析：**

*  apply\_async(func\[, args\[, kwds\]\]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；  
    close()：关闭Pool，使其不再接受新的任务；
 *  terminate()：不管任务是否完成，立即终止；
 *  join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；
 *  进程池中的Queue  
    如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

RuntimeError: Queue objects should only be shared between processes through inheritance.

下面的实例演示了进程池中的进程如何通信：

# -*- coding:utf-8 -*-
    
    # 修改import中的Queue为Manager
    from multiprocessing import Manager,Pool
    import os,time,random
    
    def reader(q):
        print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in range(q.qsize()):
            print("reader从Queue获取到消息：%s" % q.get(True))
    
    def writer(q):
        print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
        for i in "itcast":
            q.put(i)
    
    if __name__=="__main__":
        print("(%s) start" % os.getpid())
        q = Manager().Queue()  # 使用Manager中的Queue
        po = Pool()
        po.apply_async(writer, (q,))
    
        time.sleep(1)  # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据
    
        po.apply_async(reader, (q,))
        po.close()
        po.join()
        print("(%s) End" % os.getpid())

运行结果:

(11095) start
    writer启动(11097),父进程为(11095)
    reader启动(11098),父进程为(11095)
    reader从Queue获取到消息：i
    reader从Queue获取到消息：t
    reader从Queue获取到消息：c
    reader从Queue获取到消息：a
    reader从Queue获取到消息：s
    reader从Queue获取到消息：t
    (11095) End

# 协程 #

学习python协程之前，先了解一下迭代器和生成器有关的知识。

## 迭代器 ##

**迭代器**：  
迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。**迭代器只能往前不会后退。**

### 1. 可迭代对象 ###

我们已经知道可以对list、tuple、str等类型的数据使用for…in…的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。

但是，是否所有的数据类型都可以放到for…in…的语句中，然后让for…in…每次从中取出一条数据供我们使用，即供我们迭代吗？

>>> for i in 100:
    ...     print(i)
    ...
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'int' object is not iterable
    >>>
    # int整型不是iterable，即int整型不是可以迭代的
    
    # 我们自定义一个容器MyList用来存放数据，可以通过add方法向其中添加数据
    >>> class MyList(object):
    ...     def __init__(self):
    ...             self.container = []
    ...     def add(self, item):
    ...             self.container.append(item)
    ...
    >>> mylist = MyList()
    >>> mylist.add(1)
    >>> mylist.add(2)
    >>> mylist.add(3)
    >>> for num in mylist:
    ...     print(num)
    ...
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'MyList' object is not iterable
    >>>
    # MyList容器的对象也是不能迭代的

**我们自定义了一个容器类型MyList，在将一个存放了多个数据的MyList对象放到for…in…的语句中，发现for…in…并不能从中依次取出一条数据返回给我们，也就说我们随便封装了一个可以存放多条数据的类型却并不能被迭代使用。**

我们把可以通过for…in…这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterable）\*\*。

### 2. 如何判断一个对象是否可以迭代 ###

**可以使用 isinstance() 判断一个对象是否是 Iterable 对象：**

In [50]: from collections import Iterable
    
    In [51]: isinstance([], Iterable)
    Out[51]: True
    
    In [52]: isinstance({}, Iterable)
    Out[52]: True
    
    In [53]: isinstance('abc', Iterable)
    Out[53]: True
    
    In [54]: isinstance(mylist, Iterable)
    Out[54]: False
    
    In [55]: isinstance(100, Iterable)
    Out[55]: False

### 3. 可迭代对象的本质 ###

我们分析对可迭代对象进行迭代使用的过程，发现**每迭代一次（即在for…in…中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束**。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)。

**可迭代对象的本质就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。**

可迭代对象通过\_\_iter\_\_方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.

**那么也就是说，一个具备了\_\_iter\_\_方法的对象，就是一个可迭代对象。**

>>> class MyList(object):
    ...     def __init__(self):
    ...             self.container = []
    ...     def add(self, item):
    ...             self.container.append(item)
    ...     def __iter__(self):
    ...             """返回一个迭代器"""
    ...             # 我们暂时忽略如何构造一个迭代器对象
    ...             pass
    ...
    >>> mylist = MyList()
    >>> from collections import Iterable
    >>> isinstance(mylist, Iterable)
    True
    >>>
    # 这回测试发现添加了__iter__方法的mylist对象已经是一个可迭代对象了

### 4. iter()函数与next()函数 ###

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。**iter()函数实际上就是调用了可迭代对象的\_\_iter\_\_方法。**

>>> li = [11, 22, 33, 44, 55]
    >>> li_iter = iter(li)
    >>> next(li_iter)
    11
    >>> next(li_iter)
    22
    >>> next(li_iter)
    33
    >>> next(li_iter)
    44
    >>> next(li_iter)
    55
    >>> next(li_iter)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration
    >>>

注意，**当我们已经迭代完最后一个数据之后，再次调用next()函数会抛出StopIteration的异常，来告诉我们所有数据都已迭代完成，不用再执行next()函数了。**

### 5. 如何判断一个对象是否是迭代器 ###

可以使用 isinstance() 判断一个对象是否是 Iterator 对象：

In [56]: from collections import Iterator
    
    In [57]: isinstance([], Iterator)
    Out[57]: False
    
    In [58]: isinstance(iter([]), Iterator)
    Out[58]: True
    
    In [59]: isinstance(iter("abc"), Iterator)
    Out[59]: True

### 6. 迭代器Iterator ###

通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的\_\_next\_\_方法（Python3中是对象的\_\_next\_\_方法，Python2中是对象的next()方法）。所以，**我们要想构造一个迭代器，就要实现它的\_\_next\_\_方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现\_\_iter\_\_方法，而\_\_iter\_\_方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的\_\_iter\_\_方法返回自身即可。**

**一个实现了\_\_iter\_\_方法和\_\_next\_\_方法的对象，就是迭代器。**

class MyList(object):
        """自定义的一个可迭代对象"""
        def __init__(self):
            self.items = []
    
        def add(self, val):
            self.items.append(val)
    
        def __iter__(self):
            myiterator = MyIterator(self)
            return myiterator
    
    
    class MyIterator(object):
        """自定义的供上面可迭代对象使用的一个迭代器"""
        def __init__(self, mylist):
            self.mylist = mylist
            # current用来记录当前访问到的位置
            self.current = 0
    
        def __next__(self):
            if self.current < len(self.mylist.items):
                item = self.mylist.items[self.current]
                self.current += 1
                return item
            else:
                raise StopIteration
    
        def __iter__(self):
            return self
    
    
    if __name__ == '__main__':
        mylist = MyList()
        mylist.add(1)
        mylist.add(2)
        mylist.add(3)
        mylist.add(4)
        mylist.add(5)
        for num in mylist:
            print(num)

for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

### 7. 迭代器的应用场景 ###

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。**如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的**，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，**这样可以节省大量的存储（内存）空间。**

举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

现在我们想要通过for…in…循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。

class FibIterator(object):
        """斐波那契数列迭代器"""
        def __init__(self, n):
            """ :param n: int, 指明生成数列的前n个数 """
            self.n = n
            # current用来保存当前生成到数列中的第几个数了
            self.current = 0
            # num1用来保存前前一个数，初始值为数列中的第一个数0
            self.num1 = 0
            # num2用来保存前一个数，初始值为数列中的第二个数1
            self.num2 = 1
    
        def __next__(self):
            """被next()函数调用来获取下一个数"""
            if self.current < self.n:
                num = self.num1
                self.num1, self.num2 = self.num2, self.num1+self.num2
                self.current += 1
                return num
            else:
                raise StopIteration
    
        def __iter__(self):
            """迭代器的__iter__返回自身即可"""
            return self
    
    
    if __name__ == '__main__':
        fib = FibIterator(10)
        for num in fib:
            print(num, end=" ")

并不是只有for循环能接收可迭代对象,除了for循环能接收可迭代对象，list、tuple等也能接收。

li = list(FibIterator(15))
    print(li)
    tp = tuple(FibIterator(6))
    print(tp)

![在这里插入图片描述][20190909210948817.png]

## 生成器 ##

### 1. 生成器 ###

利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。**生成器是一类特殊的迭代器。**

**创建生成器方法1**  
要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 \[ \] 改成 ( )

In [15]: L = [ x*2 for x in range(5)]
    
    In [16]: L
    Out[16]: [0, 2, 4, 6, 8]
    
    In [17]: G = ( x*2 for x in range(5))
    
    In [18]: G
    Out[18]: <generator object <genexpr> at 0x7f626c132db0>
    
    In [19]:
    #创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是一个列表，而 G 是一个生成器。我们可以直接打印出列表L的每一个元素，而对于生成器G，我们可以按照迭代器的使用方法来使用，即可以通过next()函数、for循环、list()等方法使用。
    
    
    In [19]: next(G)
    Out[19]: 0
    
    In [20]: next(G)
    Out[20]: 2
    
    In [21]: next(G)
    Out[21]: 4
    
    In [22]: next(G)
    Out[22]: 6
    
    In [23]: next(G)
    Out[23]: 8
    
    In [24]: next(G)
    ---------------------------------------------------------------------------
    StopIteration                             Traceback (most recent call last)
    <ipython-input-24-380e167d6934> in <module>()
    ----> 1 next(G)
    
    StopIteration:
    
    In [25]:
    In [26]: G = ( x*2 for x in range(5))
    
    In [27]: for x in G:
       ....:     print(x)
       ....:     
    0
    2
    4
    6
    8
    
    In [28]:

**创建生成器方法2**  
generator非常强大。如果推算的算法比较复杂，用类似列表生成式的 for 循环无法实现的时候，还可以用函数来实现。

我们仍然用上一节提到的斐波那契数列来举例，回想我们在上一节用迭代器的实现方式：

注意，在用迭代器实现的方式中，我们要借助几个变量(n、current、num1、num2)来保存迭代的状态。现在我们用生成器来实现一下。

In [30]: def fib(n):
       ....:     current = 0
       ....:     num1, num2 = 0, 1
       ....:     while current < n:
       ....:         num = num1
       ....:         num1, num2 = num2, num1+num2
       ....:         current += 1
       ....:         yield num
       ....:     return 'done'
       ....:
    
    In [31]: F = fib(5)
    
    In [32]: next(F)
    Out[32]: 1
    
    In [33]: next(F)
    Out[33]: 1
    
    In [34]: next(F)
    Out[34]: 2
    
    In [35]: next(F)
    Out[35]: 3
    
    In [36]: next(F)
    Out[36]: 5
    
    In [37]: next(F)
    ---------------------------------------------------------------------------
    StopIteration                             Traceback (most recent call last)
    <ipython-input-37-8c2b02b4361a> in <module>()
    ----> 1 next(F)
    
    StopIteration: done

在使用生成器实现的方式中，我们将原本在迭代器\_\_next\_\_方法中实现的基本逻辑放到一个函数中来实现，但是**将每次迭代返回数值的return换成了yield**，此时新定义的函数便不再是函数，而是一个生成器了。简单来说：只要在def中有yield关键字的 就称为 生成器

此时按照调用函数的方式( 案例中为F = fib(5) )使用生成器就不再是执行函数体了，而是会返回一个生成器对象（ 案例中为F ），然后就可以按照使用迭代器的方式来使用生成器了。

In [38]: for n in fib(5):
       ....:     print(n)
       ....:     
    1
    1
    2
    3
    5
    
    In [39]:
    但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
    
    In [39]: g = fib(5)
    
    In [40]: while True:
       ....:     try:
       ....:         x = next(g)
       ....:         print("value:%d"%x)      
       ....:     except StopIteration as e:
       ....:         print("生成器返回值:%s"%e.value)
       ....:         break
       ....:     
    value:1
    value:1
    value:2
    value:3
    value:5
    生成器返回值:done

总结

*  使用了yield关键字的函数不再是函数，而是生成器。**（使用了yield的函数就是生成器）**
 *  yield关键字有两点作用：

1.  保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
2.  将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用  
    可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）

Python3中的生成器可以使用return返回最终运行的返回值，而Python2中的生成器不允许使用return返回一个返回值（即可以使用return从生成器中退出，但return后不能有任何表达式）。

**使用send唤醒**  
我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。

例子：执行到yield时，gen函数作用暂时保存，返回i的值; temp接收下次c.send(“python”)，send发送过来的值，c.next()等价c.send(None)

In [10]: def gen():
       ....:     i = 0
       ....:     while i<5:
       ....:         temp = yield i
       ....:         print(temp)
       ....:         i+=1
       ....:
    使用send
    
    In [43]: f = gen()
    
    In [44]: next(f)
    Out[44]: 0
    
    In [45]: f.send('haha')
    haha
    Out[45]: 1
    
    In [46]: next(f)
    None
    Out[46]: 2
    
    In [47]: f.send('haha')
    haha
    Out[47]: 3
    
    In [48]:
    使用next函数
    In [11]: f = gen()
    
    In [12]: next(f)
    Out[12]: 0
    
    In [13]: next(f)
    None
    Out[13]: 1
    
    In [14]: next(f)
    None
    Out[14]: 2
    
    In [15]: next(f)
    None
    Out[15]: 3
    
    In [16]: next(f)
    None
    Out[16]: 4
    
    In [17]: next(f)
    None
    ---------------------------------------------------------------------------
    StopIteration                             Traceback (most recent call last)
    <ipython-input-17-468f0afdf1b9> in <module>()
    ----> 1 next(f)
    
    StopIteration:
    使用__next__()方法（不常使用）
    In [18]: f = gen()
    
    In [19]: f.__next__()
    Out[19]: 0
    
    In [20]: f.__next__()
    None
    Out[20]: 1
    
    In [21]: f.__next__()
    None
    Out[21]: 2
    
    In [22]: f.__next__()
    None
    Out[22]: 3
    
    In [23]: f.__next__()
    None
    Out[23]: 4
    
    In [24]: f.__next__()
    None
    ---------------------------------------------------------------------------
    StopIteration                             Traceback (most recent call last)
    <ipython-input-24-39ec527346a9> in <module>()
    ----> 1 f.__next__()
    
    StopIteration:

### 协程 ###

协程，又称微线程，纤程。英文名Coroutine。

### 协程是啥 ###

**协程是python个中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元（理解为需要的资源）。** 为啥说它是一个执行单元，因为它自带CPU上下文。这样只要在合适的时机， 我们可以把一个协程 切换到另一个协程。 只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的。

**通俗的理解：**  
在一个协程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定

**协程和线程差异**  
在实现多任务时, 线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。 操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据，操作系统还会帮你做这些数据的恢复操作。 所以线程的切换非常耗性能。但是协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换个上百万次系统都抗的住。

### 简单实现协程yield实现 ###

import time
    
    def work1():
        while True:
            print("----work1---")
            yield
            time.sleep(0.5)
    
    def work2():
        while True:
            print("----work2---")
            yield
            time.sleep(0.5)
    
    def main():
        w1 = work1()
        w2 = work2()
        while True:
            next(w1)
            next(w2)
    
    if __name__ == "__main__":
        main()
    运行结果：
    
    ----work1---
    ----work2---
    ----work1---
    ----work2---
    ----work1---
    ----work2---
    ----work1---
    ----work2---
    ----work1---
    ----work2---
    ----work1---
    ----work2---
    ...省略...

### greenlet实现 ###

为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单

安装方式  
使用如下命令安装greenlet模块:

sudo pip3 install greenlet
    #coding=utf-8

from greenlet import greenlet
    import time
    
    def test1():
        while True:
            print "---A--"
            gr2.switch()
            time.sleep(0.5)
    
    def test2():
        while True:
            print "---B--"
            gr1.switch()
            time.sleep(0.5)
    
    gr1 = greenlet(test1)
    gr2 = greenlet(test2)
    
    #切换到gr1中运行
    gr1.switch()
    运行效果
    ---A--
    ---B--
    ---A--
    ---B--
    ---A--
    ---B--
    ---A--
    ---B--
    ...省略...

### gevent实现 ###

greenlet已经实现了协程，但是这个还的人工切换，是不是觉得太麻烦了，不要捉急，python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent

其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO  
gevent常用方法：

<table> 
 <tbody> 
  <tr> 
   <td>gevent.spawn()</td> 
   <td>创建一个普通的Greenlet对象并切换</td> 
  </tr> 
  <tr> 
   <td>gevent.spawn_later(seconds=3)</td> 
   <td>延时创建一个普通的Greenlet对象并切换</td> 
  </tr> 
  <tr> 
   <td>gevent.spawn_raw()</td> 
   <td>创建的协程对象属于一个组</td> 
  </tr> 
  <tr> 
   <td>gevent.getcurrent()</td> 
   <td>返回当前正在执行的greenlet</td> 
  </tr> 
  <tr> 
   <td>gevent.joinall(jobs)</td> 
   <td>将协程任务添加到事件循环，接收一个任务列表</td> 
  </tr> 
  <tr> 
   <td>gevent.wait()</td> 
   <td>可以替代join函数等待循环结束，也可以传入协程对象列表</td> 
  </tr> 
  <tr> 
   <td>gevent.kill()</td> 
   <td>杀死一个协程</td> 
  </tr> 
  <tr> 
   <td>gevent.killall()</td> 
   <td>杀死一个协程列表里的所有协程</td> 
  </tr> 
  <tr> 
   <td>monkey.patch_all()</td> 
   <td>非常重要，会自动将python的一些标准模块替换成gevent框架</td> 
  </tr> 
 </tbody> 
</table>

安装

pip3 install gevent

gevent的使用

import gevent
    
    def f(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
    
    g1 = gevent.spawn(f, 5)
    g2 = gevent.spawn(f, 5)
    g3 = gevent.spawn(f, 5)
    g1.join()
    g2.join()
    g3.join()
    运行结果
    
    <Greenlet at 0x10e49f550: f(5)> 0
    <Greenlet at 0x10e49f550: f(5)> 1
    <Greenlet at 0x10e49f550: f(5)> 2
    <Greenlet at 0x10e49f550: f(5)> 3
    <Greenlet at 0x10e49f550: f(5)> 4
    <Greenlet at 0x10e49f910: f(5)> 0
    <Greenlet at 0x10e49f910: f(5)> 1
    <Greenlet at 0x10e49f910: f(5)> 2
    <Greenlet at 0x10e49f910: f(5)> 3
    <Greenlet at 0x10e49f910: f(5)> 4
    <Greenlet at 0x10e49f4b0: f(5)> 0
    <Greenlet at 0x10e49f4b0: f(5)> 1
    <Greenlet at 0x10e49f4b0: f(5)> 2
    <Greenlet at 0x10e49f4b0: f(5)> 3
    <Greenlet at 0x10e49f4b0: f(5)> 4
    可以看到，3个greenlet是依次运行而不是交替运行

**gevent切换执行**

import gevent
    
    def f(n):
        for i in range(n):
            print(gevent.getcurrent(), i)
            #用来模拟一个耗时操作，注意不是time模块中的sleep
            gevent.sleep(1)
    
    g1 = gevent.spawn(f, 5)
    g2 = gevent.spawn(f, 5)
    g3 = gevent.spawn(f, 5)
    g1.join()
    g2.join()
    g3.join()
    运行结果
    
    <Greenlet at 0x7fa70ffa1c30: f(5)> 0
    <Greenlet at 0x7fa70ffa1870: f(5)> 0
    <Greenlet at 0x7fa70ffa1eb0: f(5)> 0
    <Greenlet at 0x7fa70ffa1c30: f(5)> 1
    <Greenlet at 0x7fa70ffa1870: f(5)> 1
    <Greenlet at 0x7fa70ffa1eb0: f(5)> 1
    <Greenlet at 0x7fa70ffa1c30: f(5)> 2
    <Greenlet at 0x7fa70ffa1870: f(5)> 2
    <Greenlet at 0x7fa70ffa1eb0: f(5)> 2
    <Greenlet at 0x7fa70ffa1c30: f(5)> 3
    <Greenlet at 0x7fa70ffa1870: f(5)> 3
    <Greenlet at 0x7fa70ffa1eb0: f(5)> 3
    <Greenlet at 0x7fa70ffa1c30: f(5)> 4
    <Greenlet at 0x7fa70ffa1870: f(5)> 4
    <Greenlet at 0x7fa70ffa1eb0: f(5)> 4

**给程序打补丁**

from gevent import monkey
    import gevent
    import random
    import time
    
    def coroutine_work(coroutine_name):
        for i in range(10):
            print(coroutine_name, i)
            time.sleep(random.random())
    
    gevent.joinall([
            gevent.spawn(coroutine_work, "work1"),
            gevent.spawn(coroutine_work, "work2")
    ])
    运行结果
    
    work1 0
    work1 1
    work1 2
    work1 3
    work1 4
    work1 5
    work1 6
    work1 7
    work1 8
    work1 9
    work2 0
    work2 1
    work2 2
    work2 3
    work2 4
    work2 5
    work2 6
    work2 7
    work2 8
    work2 9
    from gevent import monkey
    import gevent
    import random
    import time
    
    # 有耗时操作时需要
    monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
    
    def coroutine_work(coroutine_name):
        for i in range(10):
            print(coroutine_name, i)
            time.sleep(random.random())
    
    gevent.joinall([
            gevent.spawn(coroutine_work, "work1"),
            gevent.spawn(coroutine_work, "work2")
    ])
    运行结果
    
    work1 0
    work2 0
    work1 1
    work1 2
    work1 3
    work2 1
    work1 4
    work2 2
    work1 5
    work2 3
    work1 6
    work1 7
    work1 8
    work2 4
    work2 5
    work1 9
    work2 6
    work2 7
    work2 8
    work2 9

# 进程、线程、协程对比 #

**通俗理解**  
有一个老板想要开个工厂进行生产某件商品（例如剪子）  
他需要花一些财力物力制作一条生产线，这个生产线上有很多的器件以及材料这些所有的 为了能够生产剪子而准备的资源称之为：**进程**  
只有生产线是不能够进行生产的，所以老板的找个工人来进行生产，这个工人能够利用这些材料最终一步步的将剪子做出来，这个来做事情的工人称之为：**线程**  
这个老板为了提高生产率，想到3种办法：  
在这条生产线上多招些工人，一起来做剪子，这样效率是成倍増长，即**单进程 多线程方式**  
老板发现这条生产线上的工人不是越多越好，因为一条生产线的资源以及材料毕竟有限，所以老板又花了些财力物力购置了另外一条生产线，然后再招些工人这样效率又再一步提高了，即多进程 **多线程方式**  
老板发现，现在已经有了很多条生产线，并且每条生产线上已经有很多工人了（即程序是多进程的，每个进程中又有多个线程），为了再次提高效率，老板想了个损招，规定：如果某个员工在上班时临时没事或者再等待某些条件（比如等待另一个工人生产完谋道工序 之后他才能再次工作） ，那么这个员工就利用这个时间去做其它的事情，那么也就是说：**如果一个线程等待某些条件，可以充分利用这个时间去做其它事情，其实这就是：协程方式**

## 总结 ##

进程是资源分配的单位  
线程是操作系统调度的单位  
进程切换需要的资源很最大，效率很低  
线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）  
协程切换任务资源很小，效率高  
多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发

[20190825204315180.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/b072653156f1454b8fe696a7437d0951.gif
[20190901205449467.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/7b9d38aa47ad419db8a89555bbada97c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/0d3717a5d6dd4715947a9cf4948dc55d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/7029833779324b47af3b1fb49f3b4ab0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2k2MjIzNjcx_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/7903fd84ce114d188d5e1af9bdd4a48f.png
[20190909210948817.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/7e8d6a5525964209ad07ddb5e103c689.png