一、什么是协程

协程：实现协作式多任务，可以在程序执行内部中断，转而执行其他协程。

比如我们编写子程序（或者说函数），通常是利用“调用”来实现从 A 跳去 B，B 跳去 C，如果想回来调用方，必须等被调用方执行完才行，整个调用过程是通过栈实现的。而协程是运行子程序的过程中“中断”，转而执行其他子程序，再在适当的时候返回来接着运行。

二、协程与线程的区别

协程相比于线程的优势： 1、协程效率比线程高。线程间切换需要开销，而协程间切换是由程序自身控制的，不需要开销。 2、协程不需要多线程的锁机制。协程是在一个线程内进行切换，所以不存在同时写变量冲突，不需要给共享资源加锁，只需要判断状态。

PS：如果想使用多CPU的话，可以使用进程+协程。

三、协程的实现

协程是通过yield实现的，所以协程是生成器，可以通过 next 调用。

def simple(a):
    print("----start----")
    r = yield a
    print('----r------' + str(r))

>>> my_simple = simple(5)
>>> my_simple
<generator object simple at 0x10f9242b0>
>>> next(my_simple)
----start----
5
>>> my_simple.send(8)
----r------8
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

以上是一个简单的协程例子，可以看到，my_simple是一个生成器实例，需要使用next()方法或send(None)去预激协程，协程运行到yield的时候停止，当使用send()方法给yield赋值时，程序继续往下运行，并抛出StopIteration异常。

四、协程返回值

在python3.3版本后，协程可以有返回值。

def simple(a):
    print("----start----")
    r = yield a
    print('----r------' + str(r))
    return r
    
>>> my_simple = simple(5)
>>> next(my_simple)
----start----
5
>>> my_simple.send(8)
----r------8
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration: 8

可以看到，在程序运行完后，异常对象StopIteration的value属性保存着返回的值。

五、使用yield from获取协程返回值

对于yield from来说，解释器不仅会捕获StopIteration异常，还会把value属性的值作为yield from表达式的值。

yield from主要功能是打开双向通道，把最外层的调用方和最内层的子生成器连接起来。

# 子生成器
def total_num():
 total = 0
 while True:
  num = yield
  if num == None:
   break
  total += num
 return total


# 委派生成器
def send_num(result, key):
 while True:
  result[key] = yield from total_num()


# 调用方
def main(data):
 result = {}
 for key, nums in data.items():
  group = send_num(result, key)
  next(group)
  for num in nums:
   group.send(num)
  group.send(None)
 print(result)


data = {
 'nums1': [12, 34, 23, 4, 35, 34, 34, 55],
 'nums2': [22, 44, 33, 24, 33, 24, 4, 15],
 'nums3': [32, 54, 43, 41, 31, 44, 24, 25],
 'nums4': [42, 64, 53, 43, 37, 74, 74, 35],
 'nums5': [52, 74, 63, 46, 39, 84, 44, 45]
}


if __name__ == "__main__":
 main(data)

输出结果如下：

{'nums1': 231, 'nums2': 199, 'nums3': 294, 'nums4': 422, 'nums5': 447}

委派生成器作为双向管道把调用方和子生成器连接起来，委派生成器在yield from表达式处暂停时，调用方通过send()方法把数据传给子生成器，子生成器再把产出值发送给调用方，子生成器返回后，会抛出StopIteration异常，并把返回值添加到异常的value属性上，此时你异常生成器会恢复，并获取异常的value值作为yield from表达式的值。

委派生成器相当于管道，所以可以把任意个委派生成器连起来：委派生成器连接的子生成器是一个委派生成器，以此类推，直到遇到一个使用yield的生成器或可迭代对象。

六、总结

1、协程是用于控制程序中断，它与函数调用不同

2、协程是在单线程里可处理多任务，相比多线程节省了线程切换的开销

3、协程通过 yield 关键字实现，它也是一种生成器

4、协程调用方可通过 send() 方法给被调用方发送值。协程的开启需要预激，预激方法是：send(None)或者next()

5、协程在 python3.3 之后是有返回值的，返回值会放在 StopIteration 异常的 value 里

6、yield from 的作用是在生成器里调用子生成器，可以优化一个嵌套 for 循环等复杂代码

7、协程有四种状态：GEN_CREATED(等待开始执行)、GEN_RUNNING(解释器正在执行)、GEN_SUSPENDED(在yield表达式处停止)、GEN_CLOSED(执行结束)。通过 inspect.getgeneratorstate(...) 函数可获取

8、结束协程的两种方式：generator.throw 或 generator.close

七、相关面试题

上面介绍了协程的概念，相对应的这里提供几个关于协程的面试题目。

理论结合“面试”

1、什么是进程、线程、协程？

答案要点： a、进程是资源分配，每个进程拥有独立的资源空间，因为进程不共享资源，所以就涉及到进程间通信的方式，常见的方式有：消息队列、管道、信号量、socket套接字等。（这里会引申出几个面试题：进程间有通信方式有哪些？-> 使用过哪些消息队列？）

b、线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。线程是在进程下，所以同一进程下的多个线程是能共享资源的。线程能共享的资源有：堆、全局变量、文件描述符和信号处理等，不共享的资源：栈、寄存器等（这里会引申出的面试题：多线程怎么实现？-> 多线程并发问题 -> 多线程共享哪些资源）

c、协程是单线程下实现多任务，它通过 yield 关键字来实现，能有效地减少多线程之间切换的开销。它是一种比线程更加轻量级的存在。正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程。

2、协程有什么优缺点？ 答案要点 a、协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行），性能得到了很大的提升，不会像线程切换那样消耗资源。

b、缺点：异步代码，可能不那么容易理解和调度

3、下面代码输出结果是什么？

def test():
    print("1"*30)
    yield "A"
    print("A"*30)
    yield "B"
    print("B"*30)

t = test()  # 1
print(next(t))  # 2
print(next(t))  # 3
print(next(t))  # 4

答案要点： 这其实是属于生成器的一个题目，输出如下： 1：没有任何输出，它不会执行 print("1"*30)，只会返回一个生成器 2：输出 "111...111"(30个)，同时打印返回值"A" 3：输出 "111...111"(30个)，同时打印返回值"B" 4：异常、StopIteration

4、请写一个简单的协程示例 或 利用协程实现一个 生产者消费者 模式

面试一般其实比较少说让面试者手写一个协程代码，不过之前确实有遇到过让手写一个利用协程实现生产者消费者模式的。示例代码如下(代码来源于：https://www.liaoxuefeng.com/wiki/897692888725344/923057403198272)：

import time

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'

def produce(c):
    c.next()
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    # 终止协程
    # 终止协程的方式：generator.throw 或者 generator.close
    c.close()

if __name__=='__main__':
    c = consumer()
    produce(c)