維基百科協(xié)程定義：

協(xié)程 是為非搶占式多任務產生子程序的計算機程序組件宣谈，
協(xié)程允許不同入口點在不同位置暫鸵遄叮或開始執(zhí)行程序。
通俗來說笔诵，協(xié)程就是你可以暫停啟動執(zhí)行的函數(shù)谅将。

web服務以I/O是瓶頸，而這這是協(xié)程所擅長的：
多任務并發(fā)鸠蚪，每個任務在合適的時候掛起（發(fā)起I/O）和恢復(I/O結束)

Python中的協(xié)程經歷了很長的一段發(fā)展歷程巡球。其大概經歷了如下三個階段：

1.最初的生成器變形yield/send
2.引入@asyncio.coroutine和yield from
3.在最近的Python3.5版本中引入async/await關鍵字

Python 2.2中，生成器第一次在PEP 255中提出（那時也把它成為迭代器邓嘹，因為它實現(xiàn)了迭代器協(xié)議(https://docs.python.org/3/library/stdtypes.html#iterator-types)

從yield說起：

def old_fib(n):
    res = [0] * n
    index = 0
    a = 0
    b = 1
    while index < n:
        res[index] = b
        a, b = b, a + b
        index += 1
    return res
        
print('-'*10 + 'test old fib' + '-'*10)
for fib_res in old_fib(20):
    print(fib_res)

如果我們僅僅是需要拿到斐波那契序列的第n位酣栈，或者僅僅是希望依此產生斐波那契序列，那么上面這種傳統(tǒng)方式就會比較耗費內存汹押。

這時矿筝，yield就派上用場了。

def fib(n):
    index = 0
    a = 0
    b = 1
    while index < n:
        yield b
        a, b = b, a + b
        index += 1

print('-'*10 + 'test yield fib' + '-'*10)
for fib_res in fib(20):
    print(fib_res)

當一個函數(shù)中包含yield語句時棚贾，python會自動將其識別為一個生成器窖维。這時fib(20)并不會真正調用函數(shù)體，而是以函數(shù)體生成了一個生成器對象實例妙痹。
yield在這里可以保留fib函數(shù)的計算現(xiàn)場铸史，暫停fib的計算并將b返回。而將fib放入for…in循環(huán)中時怯伊，每次循環(huán)都會調用next(fib(20))琳轿，喚醒生成器，執(zhí)行到下一個yield語句處耿芹，直到拋出StopIteration異常崭篡。此異常會被for循環(huán)捕獲，導致跳出循環(huán)

如果可以利用生成器“暫桶娠酰”的部分琉闪，添加“將東西發(fā)送回生成器”的功能，那么 Python 突然就有了協(xié)程的概念砸彬。

將東西發(fā)送回暫停了的生成器這一特性通過 PEP 342添加到了 Python 2.5颠毙。與其它特性一起斯入，PEP 342 為生成器引入了 send() 方法。這讓我們不僅可以暫停生成器蛀蜜，而且能夠傳遞值到生成器暫停的地方刻两。

python yield底層實現(xiàn):https://www.cnblogs.com/coder2012/p/4990834.html

Send

從上面的程序中可以看到，目前只有數(shù)據(jù)從fib(20)中通過yield流向外面的for循環(huán)涵防；如果可以向fib(20)發(fā)送數(shù)據(jù)闹伪，那就可以在Python中實現(xiàn)協(xié)程了（實現(xiàn)了協(xié)程的定義）沪铭。

于是壮池，Python中的生成器有了send函數(shù)，yield表達式也擁有了返回值杀怠。

我們用這個特性椰憋，模擬一個額慢速斐波那契數(shù)列的計算：

def stupid_fib(n):
    index = 0
    a = 0
    b = 1
    while index < n:
        sleep_cnt = yield b
        print('let me think {0} secs'.format(sleep_cnt))
        time.sleep(sleep_cnt)
        a, b = b, a + b
        index += 1
print('-'*10 + 'test yield send' + '-'*10)
N = 20
sfib = stupid_fib(N)
fib_res = next(sfib)
while True:
    print(fib_res)
    try:
        fib_res = sfib.send(random.uniform(0, 0.5))
    except StopIteration:
        break

其中next(sfib)相當于sfib.send(None)，可以使得sfib運行至第一個yield處返回赔退。后續(xù)的sfib.send(random.uniform(0, 0.5))則將一個隨機的秒數(shù)發(fā)送給sfib橙依，作為當前中斷的yield表達式的返回值。
這樣硕旗，我們可以從“主”程序中控制協(xié)程計算斐波那契數(shù)列時的思考時間窗骑，協(xié)程可以返回給“主”程序計算結果

yield from

Python3.3版本的PEP 380中添加了yield from語法，允許一個generator生成器將其部分操作委派給另一個生成器漆枚。
[圖片上傳失敗...(image-e08049-1529418139789)]

提供了一個調用者和子生成器之間的透明的雙向通道创译。包括從子生成器獲取數(shù)據(jù)以及向子生成器傳送數(shù)據(jù)

對于簡單的迭代器

yield from iterator    

(本質上)相當于：

for x in iterator:
    yield x

yield from用于重構生成器，簡單的墙基，可以這么使用：

def copy_fib(n):
    print('I am copy from fib')
    yield from fib(n)
    print('Copy end')
print('-'*10 + 'test yield from' + '-'*10)
for fib_res in copy_fib(20):
    print(fib_res)

asyncio.coroutine和yield from

yield from在asyncio模塊中得以發(fā)揚光大：

@asyncio.coroutine
def smart_fib(n):
    index = 0
    a = 0
    b = 1
    while index < n:
        sleep_secs = random.uniform(0, 0.2)
        yield from asyncio.sleep(sleep_secs)
        print('Smart one think {} secs to get {}'.format(sleep_secs, b))
        a, b = b, a + b
        index += 1

@asyncio.coroutine
def stupid_fib(n):
    index = 0
    a = 0
    b = 1
    while index < n:
        sleep_secs = random.uniform(0, 0.4)
        yield from asyncio.sleep(sleep_secs)
        print('Stupid one think {} secs to get {}'.format(sleep_secs, b))
        a, b = b, a + b
        index += 1

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [
        asyncio.async(smart_fib(10)),
        asyncio.async(stupid_fib(10)),
    ]
    loop.run_until_complete(asyncio.wait(tasks))
    print('All fib finished.')
    loop.close()

asyncio是一個基于事件循環(huán)的實現(xiàn)異步I/O的模塊软族。通過yield from，我們可以將協(xié)程asyncio.sleep的控制權交給事件循環(huán)残制，然后掛起當前協(xié)程立砸；之后，由事件循環(huán)決定何時喚醒asyncio.sleep,接著向后執(zhí)行代碼初茶。

這樣說可能比較抽象颗祝，好在asyncio是一個由python實現(xiàn)的模塊，那么我們來看看asyncio.sleep中都做了些什么：

@coroutine
def sleep(delay, result=None, *, loop=None):
    """Coroutine that completes after a given time (in seconds)."""
    future = futures.Future(loop=loop)
    h = future._loop.call_later(delay,
                                future._set_result_unless_cancelled, result)
    try:
        return (yield from future)
    finally:
        h.cancel()

首先恼布，sleep創(chuàng)建了一個Future對象吐葵，作為更內層的協(xié)程對象，通過yield from交給了事件循環(huán)桥氏；其次温峭，它通過調用事件循環(huán)的call_later函數(shù)，注冊了一個回調函數(shù)字支。

通過查看Future類的源碼凤藏，可以看到奸忽，F(xiàn)uture是一個實現(xiàn)了iter對象的生成器：

  class Future:
    #blabla...
    def __iter__(self):
        if not self.done():
            self._blocking = True
            yield self  # This tells Task to wait for completion.
        assert self.done(), "yield from wasn't used with future"
        return self.result()  # May raise too.

那么當我們的協(xié)程yield from asyncio.sleep時，事件循環(huán)其實是與Future對象建立了聯(lián)系揖庄。每次事件循環(huán)調用send(None)時栗菜，其實都會傳遞到Future對象的iter函數(shù)調用；而當Future尚未執(zhí)行完畢的時候蹄梢，就會yield self疙筹，也就意味著暫時掛起，等待下一次send(None)的喚醒禁炒。

當我們包裝一個Future對象產生一個Task對象時而咆，在Task對象初始化中，就會調用Future的send(None),并且為Future設置好回調函數(shù)幕袱。

  class Task(futures.Future):
    #blabla...
    def _step(self, value=None, exc=None):
        #blabla...
        try:
            if exc is not None:
                result = coro.throw(exc)
            elif value is not None:
                result = coro.send(value)
            else:
                result = next(coro)
        #exception handle
        else:
            if isinstance(result, futures.Future):
                # Yielded Future must come from Future.__iter__().
                if result._blocking:
                    result._blocking = False
                    result.add_done_callback(self._wakeup)
        #blabla...

    def _wakeup(self, future):
        try:
            value = future.result()
        except Exception as exc:
            # This may also be a cancellation.
            self._step(None, exc)
        else:
            self._step(value, None)
        self = None  # Needed to break cycles when an exception occurs.

預設的時間過后暴备，事件循環(huán)將調用Future._set_result_unless_cancelled:

class Future:
    #blabla...
    def _set_result_unless_cancelled(self, result):
        """Helper setting the result only if the future was not cancelled."""
        if self.cancelled():
            return
        self.set_result(result)

    def set_result(self, result):
        """Mark the future done and set its result.

        If the future is already done when this method is called, raises
        InvalidStateError.
        """
        if self._state != _PENDING:
            raise InvalidStateError('{}: {!r}'.format(self._state, self))
        self._result = result
        self._state = _FINISHED
        self._schedule_callbacks()

這將改變Future的狀態(tài)，同時回調之前設定好的Tasks._wakeup们豌；在_wakeup中涯捻，將會再次調用Tasks._step，這時望迎，F(xiàn)uture的狀態(tài)已經標記為完成障癌，因此，將不再yield self辩尊，而return語句將會觸發(fā)一個StopIteration異常涛浙，此異常將會被Task._step捕獲用于設置Task的結果。同時对省，整個yield from鏈條也將被喚醒蝗拿，協(xié)程將繼續(xù)往下執(zhí)行。

async和await

弄清楚了asyncio.coroutine和yield from之后蒿涎，在Python3.5中引入的async和await就不難理解了：可以將他們理解成asyncio.coroutine/yield from的完美替身哀托。當然，從Python設計的角度來說劳秋，async/await讓協(xié)程表面上獨立于生成器而存在仓手，將細節(jié)都隱藏于asyncio模塊之下，語法更清晰明了玻淑。

async def smart_fib(n):
    index = 0
    a = 0
    b = 1
    while index < n:
        sleep_secs = random.uniform(0, 0.2)
        await asyncio.sleep(sleep_secs)
        print('Smart one think {} secs to get {}'.format(sleep_secs, b))
        a, b = b, a + b
        index += 1

async def stupid_fib(n):
    index = 0
    a = 0
    b = 1
    while index < n:
        sleep_secs = random.uniform(0, 0.4)
        await asyncio.sleep(sleep_secs)
        print('Stupid one think {} secs to get {}'.format(sleep_secs, b))
        a, b = b, a + b
        index += 1

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [
        asyncio.ensure_future(smart_fib(10)),
        asyncio.ensure_future(stupid_fib(10)),
    ]
    loop.run_until_complete(asyncio.wait(tasks))
    print('All fib finished.')
    loop.close()

Python中的協(xié)程就介紹完畢了嗽冒。示例程序中都是以sleep為異步I/O的代表，在實際項目中补履，可以使用協(xié)程異步的讀寫網(wǎng)絡添坊、讀寫文件、渲染界面等箫锤，而在等待協(xié)程完成的同時贬蛙，CPU還可以進行其他的計算雨女。協(xié)程的作用正在于此。