【Python】协程的概念与实现

一、协程概念

python多线程中，两个子线程会频繁的切换直到结束，操作系统就得不停的保存上下文，切换上下文，带来了很多额外的开销。

为了减少开销，提出了协程的概念。

协程是用户级的线程，是线程之上的轻量级线程。

事实上，协程本质就是用户态下的线程，进程里的线程的切换调度是由操作系统来负责的。但是线程内的协程的调度执行，是由线程来负责的。如果我们把协程对应到原生线程，那么协程所在的原生线程就是操作系统的角色。即原生线程需要负责什么时候切换协程，什么时候挂起协程。协程切换的时候，线程需要把协程A的执行环境进行保存，在下一次执行A的时候，线程需要恢复执行环境，这样就可以从A之前的位置继续执行。（类比一下，有了协程的存在，原来的线程变成操作系统，现在的协程变成了线程。）

用户线程即为协程，操作系统感知不到协程的存在，只调度内核线程。

在这里我们需要提醒的是，多线程的使用是可以让一个程序获得更多的计算时间的，但是协程的使用不会， 多线程的使用在多核的情况下，可以达到并行的效果，但是协程的使用不会达到并行的效果。因为操作系统感知不到协程的存在，只会把时间片和CPU核心分给线程。至于分给线程的时间，线程又会分配给哪个协程来运行，那是线程自己决定的内容。比如分配2ms给一个拥有两个协程的线程A，线程被操作系统调度指派给了CPU核心C1， A会决定在C1运行哪个线程，,可以雨露均沾，让两个协程各自运行1ms, 也可以是把2ms全部分配给一个协程，自始至终，所有的协程都运行在CPU核心C1上，所以无法实现协程并行。

线程内部自主进行协程调度。

那使用协程的好处是什么呢？提高线程的并发度，减小切换的开销，其结论就是，协程的切换只是线程栈内的切换操作，不涉及内核操作，其切换速度远快于线程。

如果我们要实现协程调度，我们该实现哪些功能呢。比如有一个线程底下有两个协程A，B，根据用户输入的文件名，A协程进行文件读取，并返回文件内容，B协程根据文件名计算哈希值并返回。

# 以下代码并非真实的python协程代码，只是为了说明例子    
def coroutine_A(file_path):
    file_object = open(file_path)
    #协程执行到文件阅读，则挂起协程，切换到B
    data = file_object.read()
    #数据准备好之后，线程获得通知，然后在未来某个时刻调度协程A继续执行
    file_object.close()
    return data 
 
def coroutine_B(file_path):
    hash_value = Hash(file_path)
    return hash_value 

线程首先调度执行A，执行到文件读取部分发现需要等待，于是挂起协程A并切换到协程B执行。所以要实现调度协程，那么至少需要实现协程挂起操作和协程恢复运行两个操作， 如果不想手动进行调度，那么可以实现一个中央的调度器来帮助进行调度。

二、协程python实现

协程主要有如下两个特点：

• 协程可以保留运行时的状态数据
• 协程可以出让自己的执行权，当重新获得执行权时从上一次暂停的位置继续执行

保留运行时状态数据就是上下文切换时做的工作，便于下一次执行时能继续上一次暂停的位置执行。协程出让执行权，指的是如果线程指定一个协程运行，除非该协程主动放弃执行权，不然线程无法将协程挂起切换。

                                                          图： 线程调度——上下文切换

Lua很早就有了语言级别对协程的实现，我个人觉得其协程API还是比较清晰的， 在这里简单介绍说明一下。

import asyncio
import time
# async关键字表明这是个协程
async def coroutine_A():
    # 这一块函数是一个协程块，而不是普通的函数模块（函数模块从中间退出之后，是不会保留运行环境的，但是协程会保留）
    print("协程A开始执行")
    print("协程A出让执行权")
    # await关键字表明主动出让执行权
    """
    协程出让执行权，指的是如果线程指定一个协程运行，除非该协程主动放弃执行权，不然线程无法将协程挂起切换
    """
    await asyncio.sleep(2)
    print("协程A重新获得执行权,并执行结束")

async def coroutine_B():
    print("协程B开始执行")
    print("协程B出让执行权")
    await asyncio.sleep(2)
    print("协程B重新获得执行权,并执行结束")

async def coroutine_C():
    while(1):
        print("由于协程A,B始终等待时钟信号，协程C执行")
        await asyncio.sleep(0.4)

if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    # 定义三个协程模块，并让调度器进行调度执行A和B
    group1 = [coroutine_B(),coroutine_A()] # list中B在A前，就是首先调度运行B
    # group2 = [coroutine_B(),coroutine_A(),coroutine_C()]
    """
    首先调度运行协程B, 运行到sleep函数的时候遇到await关键字并出让执行权，
        (备注：这个sleep函数在实际场景下，就是我们要准备开启的子线程，但实际上，我们不知道子线程什么时候结束，通常用join。
        这里sleep(2)，2s实际也是不知道的。)
    这时调度器切换执行协程A，协程A执行又遇到await，再一次出让执行权。
    这时两个协程都在等待唤醒的信号。等待到了信号之后，两个协程被唤醒进而调度执行，然后运行结束。
    """
    group1 = asyncio.gather(*group1)
    loop.run_until_complete(asyncio.gather(group1, return_exceptions=True))
    print("程序运行时间: {}".format(time.time() - start_time))


"""
group1
协程B开始执行
协程B出让执行权
协程A开始执行
协程A出让执行权
协程B重新获得执行权,并执行结束
协程A重新获得执行权,并执行结束
程序运行时间: 2.001267194747925
"""


"""
group2
此时我们加上第三个协程进行调度，这样当A、B等待时钟信号的时候我们在等待的期间，让调度器执行调度
协程C，虽然协程C也调用sleep函数，但是由于睡眠时间短，所以很快又会被唤醒进行调度执行。
当然了，由于协程C是死循环，所以协程A、B结束之后，会一直执行协程C。
------------------------------------------------------
协程B开始执行
协程B出让执行权
协程A开始执行
协程A出让执行权
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
协程B重新获得执行权,并执行结束
协程A重新获得执行权,并执行结束
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
由于协程A,B始终等待时钟信号，协程C执行
...
重复“由于协程A,B始终等待时钟信号，协程C执行”
"""

我们前面提到过，协程的两大特点，一是可以保存运行时环境，另一个便是可以主动出让执行权。那么假如有一个协程C始终不出让执行权，即在代码中，不用await关键字，那么其他协程是不是就没办法被执行了呢，很不幸的是，的确是这样的。我们看下代码

import asyncio
import time
async def coroutine_A():
    print("协程A开始执行")
    print("协程A出让执行权")
    await asyncio.sleep(2)
    print("协程A重新获得执行权,并执行结束")

async def coroutine_B():
    print("协程B开始执行")
    print("协程B出让执行权")
    await asyncio.sleep(2)
    print("协程B重新获得执行权,并执行结束")
 
# 协程C始终不出让执行权
async def coroutine_C():
    while(1):
        time.sleep(0.4)
        print("协程C不使用await关键字，故不选择出让执行权，所以继续执行C")

if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    group1 = [coroutine_C(),coroutine_A(),coroutine_B()]
    group1 = asyncio.gather(*group1) # 并发运行group1中等待的任务
    loop.run_until_complete(asyncio.gather(group1, return_exceptions=True))
    print("程序运行时间: {}".format(time.time() - start_time))

程序运行结果

协程B开始执行
协程B出让执行权
协程A开始执行
协程A出让执行权
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
协程C不使用await关键字，故不选择出让执行权，所以继续执行C
...

从结果中我们可以看到，B和A都主动出让了执行权，但由于C中虽然同样调用了sleep()函数，但是没有使用await关键字来出让执行权，所以始终C就被执行，永远轮不到A和B执行了。

---

以上代码使用了很多api，详细功能见官方文档。

loop = asyncio.get_event_loop() # 获取当前事件循环

官方api解释：

Get the current event loop.

If there is no current event loop set in the current OS thread, the OS thread is main, and set_event_loop() has not yet been called, asyncio will create a new event loop and set it as the current one.

asyncio.gather(*group1) # 并发运行group1中等待的任务

loop.run_until_complete(asyncio.gather(group1, return_exceptions=True))  # 如果参数是协程对象，则将其隐式调度为作为asyncio.Task运行

loop.run_until_complete(future)

Run until the future (an instance of Future) has completed.

If the argument is a coroutine object it is implicitly scheduled to run as a asyncio.Task.

Return the Future’s result or raise its exception.

参考：

Python线程、协程探究（2）——揭开协程的神秘面纱 - 大龙的文章 - 知乎

https://docs.python.org/zh-cn 中文文档

https://docs.python.org/3/library/asyncio-eventloop.html 英文文档，英文里的api更多一些

 

至此，只是了解了一些概念，距离项目实战还有很远的距离哦~