Python高级技术之：`Python`的`asyncio`和`GIL`：`await`在`GIL`中的释放时机。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位观众老爷，晚上好！我是你们的老朋友，BUG终结者。今天咱们来聊聊Python异步编程里一个让人又爱又恨的话题：asyncio和GIL的爱恨纠葛，重点剖析await在GIL中的释放时机。

开场白：GIL这货，甩也甩不掉的影子

话说Python这门语言啊，简单易用，深受广大程序员的喜爱。但是！凡事都有个“但是”，Python有个全局解释器锁（Global Interpreter Lock，简称GIL），它就像一个看场子的保安，每次只允许一个线程执行Python字节码。这就意味着，即使你的机器有八核、十六核，Python的多线程也只能“伪并发”，并不能真正利用多核优势。

但是，咱们程序员也不是吃素的，GIL挡不住我们追求高性能的脚步。于是，asyncio横空出世，它是一种基于单线程的并发模型，通过事件循环来调度协程，从而实现高效的IO密集型任务处理。

正餐：asyncio的崛起和await的妙用

asyncio的核心思想是：当一个协程在等待IO操作（比如网络请求、文件读写）时，它可以主动让出控制权，让其他协程有机会执行，从而避免阻塞。这种让出控制权的操作，就是通过await关键字来实现的。

await，让出控制权的钥匙

await后面通常跟着一个awaitable对象，这个对象可以是一个协程（coroutine）、一个任务（task）或者一个实现了__await__方法的对象。当await遇到一个awaitable对象时，它会做以下几件事：

暂停当前协程的执行。 就像按下了暂停键，当前协程暂时停止运行。
将控制权交还给事件循环。 事件循环会寻找下一个可以执行的协程。
当awaitable对象完成时，恢复当前协程的执行。 就像按下了播放键，当前协程从暂停的地方继续运行。

重点来了：await在GIL中的释放时机

现在，我们来重点讨论await在GIL中的释放时机。这才是今天讲座的灵魂所在！

简单来说，当await遇到一个IO操作时，它会释放GIL，让其他线程有机会执行Python字节码。但是，这里面有很多细节需要注意。

不是所有的await都会释放GIL。 只有当awaitable对象在等待IO操作时，才会释放GIL。如果awaitable对象是一个CPU密集型的任务，它可能不会释放GIL。
GIL的释放和获取是有代价的。 频繁地释放和获取GIL会带来额外的开销，所以我们需要尽量避免不必要的GIL释放。

代码说话：await释放GIL的场景

让我们通过一些代码示例来说明await释放GIL的场景。

示例1：网络请求

import asyncio
import aiohttp
import threading

async def fetch_url(url):
    print(f"线程 {threading.current_thread().name}: 开始请求 {url}")
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            print(f"线程 {threading.current_thread().name}: 请求 {url} 完成")
            return await response.text()  # await在这里会释放GIL

async def main():
    tasks = [
        fetch_url("https://www.example.com"),
        fetch_url("https://www.baidu.com")
    ]
    results = await asyncio.gather(*tasks)
    print(results)

if __name__ == "__main__":
    asyncio.run(main())

在这个例子中，await response.text()会释放GIL，因为response.text()是一个IO操作，它需要等待服务器返回数据。当await释放GIL时，其他线程就可以执行Python字节码了。

示例2：文件读写

import asyncio
import aiofiles
import threading

async def read_file(filename):
    print(f"线程 {threading.current_thread().name}: 开始读取文件 {filename}")
    async with aiofiles.open(filename, mode='r') as f:
        content = await f.read() # await在这里会释放GIL
    print(f"线程 {threading.current_thread().name}: 文件 {filename} 读取完成")
    return content

async def main():
    tasks = [
        read_file("file1.txt"),
        read_file("file2.txt")
    ]
    results = await asyncio.gather(*tasks)
    print(results)

if __name__ == "__main__":
    # 创建两个空文件
    with open("file1.txt", "w") as f:
        f.write("This is file1.n")
    with open("file2.txt", "w") as f:
        f.write("This is file2.n")

    asyncio.run(main())

在这个例子中，await f.read()会释放GIL，因为f.read()是一个IO操作，它需要等待文件系统返回数据。

示例3：asyncio.sleep()

import asyncio
import threading

async def my_coroutine(delay):
    print(f"线程 {threading.current_thread().name}: 协程开始，休眠 {delay} 秒")
    await asyncio.sleep(delay)  # await在这里会释放GIL
    print(f"线程 {threading.current_thread().name}: 协程结束")

async def main():
    tasks = [
        my_coroutine(1),
        my_coroutine(2)
    ]
    await asyncio.gather(*tasks)

if __name__ == "__main__":
    asyncio.run(main())

在这个例子中，await asyncio.sleep(delay)会释放GIL，因为asyncio.sleep()会暂停当前协程的执行，并将控制权交还给事件循环。

反例：CPU密集型任务

import asyncio
import time
import threading

def cpu_bound_task(n):
    # 模拟一个CPU密集型任务
    sum = 0
    for i in range(n):
        sum += i * i
    return sum

async def main():
    print(f"线程 {threading.current_thread().name}: 开始CPU密集型任务")
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, cpu_bound_task, 10000000) # await在这里不会释放GIL， 因为loop.run_in_executor在一个单独的线程中运行cpu_bound_task
    print(f"线程 {threading.current_thread().name}: CPU密集型任务完成，结果: {result}")

if __name__ == "__main__":
    asyncio.run(main())

在这个例子中，await loop.run_in_executor(None, cpu_bound_task, 10000000) 并不会直接释放GIL。loop.run_in_executor 会将 cpu_bound_task 提交到一个线程池中执行，这个CPU密集型任务是在另一个线程中执行的，而这个线程会持有GIL直到任务完成。虽然主线程会await这个结果，但是GIL的释放和获取是在线程池的线程中进行的，而不是在主线程的asyncio事件循环中。

总结：await和GIL的恩怨情仇

让我们用一个表格来总结一下await和GIL的关系：

操作类型	是否释放GIL	说明
网络IO	是	`aiohttp`、`asyncio.open_connection`等
文件IO	是	`aiofiles`等
`asyncio.sleep()`	是	暂停协程执行，让出控制权
CPU密集型任务	否	除非使用`loop.run_in_executor`放到线程池中执行，否则不会释放GIL。但是，线程池的线程会持有GIL.

高级技巧：手动释放GIL

虽然asyncio会自动释放GIL，但在某些特殊情况下，我们可能需要手动释放GIL。Python提供了一个threading.release_lock()函数来手动释放GIL，以及threading.acquire_lock()函数来手动获取GIL。但是，手动释放GIL需要非常小心，否则可能会导致程序崩溃。

警告：手动释放GIL有风险，请谨慎使用！

最佳实践：避免不必要的GIL释放

频繁地释放和获取GIL会带来额外的开销，所以我们需要尽量避免不必要的GIL释放。以下是一些最佳实践：

尽量使用asyncio提供的异步库。 这些库通常已经优化了GIL的释放和获取。
避免在协程中执行CPU密集型任务。 如果必须执行CPU密集型任务，可以使用loop.run_in_executor将其放到线程池中执行。
尽量减少协程的数量。 过多的协程会增加事件循环的调度开销。

结语：掌握await，驾驭asyncio

asyncio是一种强大的并发模型，可以帮助我们构建高性能的IO密集型应用程序。理解await在GIL中的释放时机，可以让我们更好地利用asyncio，避免性能瓶颈。

希望今天的讲座对大家有所帮助。记住，编程就像谈恋爱，需要不断学习和探索，才能找到最适合自己的姿势！

下次再见！

发表回复 取消回复

发表回复取消回复