python并发编程之协程库：探索Python中的协程库

本文链接：https://blog.youkuaiyun.com/qq_41314882/article/details/133804213

本文探讨了Python中的asyncio、gevent和trio三个主要协程库，通过10个实际场景展示了它们在处理异步IO、并发网络请求、文件操作、定时任务、数据库访问、HTTP服务器和任务队列等方面的应用，帮助理解并发编程和提高程序性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

点击蓝字，关注我们

协程是一种轻量级的并发编程模型，它可以在单线程中实现高效的异步操作。Python提供了多个协程库，其中最常用的是`asyncio`、`gevent`和`trio`。下面我将探索这些协程库，并列举10个实用的场景代码，展示它们在异步编程中的应用。

1. 使用`asyncio`实现异步IO操作：

import asyncio

async def fetch_data(url):
    # 模拟异步IO操作
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    tasks = [
        fetch_data("https://api.example.com/data1"),
        fetch_data("https://api.example.com/data2"),
        fetch_data("https://api.example.com/data3")
    ]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main()))

2. 使用`gevent`实现并发网络请求：

import gevent
import requests

def fetch_data(url):
    response = requests.get(url)
    return response.text

def main():
    urls = [
        "https://api.example.com/data1",
        "https://api.example.com/data2",
        "https://api.example.com/data3"
    ]
    jobs = [gevent.spawn(fetch_data, url) for url in urls]
    gevent.joinall(jobs)
    results = [job.value for job in jobs]
    print(results)

main()

3. 使用`trio`实现异步文件读写：

import trio

async def read_file(file_name):
    async with trio.open_file(file_name, "r") as file:
        data = await file.read()
        return data

async def write_file(file_name, data):
    async with trio.open_file(file_name, "w") as file:
        await file.write(data)

async def main():
    await write_file("output.txt", "Hello, world!")
    data = await read_file("output.txt")
    print(data)

trio.run(main)

4. 使用`asyncio`处理并发任务：

import asyncio

async def task(name):
    print(f"Task {name} started")
    await asyncio.sleep(1)
    print(f"Task {name} completed")

async def main():
    tasks = [task("A"), task("B"), task("C")]
    await asyncio.gather(*tasks)

asyncio.run(main())

5. 使用`gevent`实现并发爬虫：

import gevent
import requests
from gevent import monkey

monkey.patch_all()

def fetch_data(url):
    response = requests.get(url)
    return response.text

def main():
    urls = [
        "https://www.example.com/page1",
        "https://www.example.com/page2",
        "https://www.example.com/page3"
    ]
    jobs = [gevent.spawn(fetch_data, url) for url in urls]
    gevent.joinall(jobs)
    results = [job.value for job in jobs]
    print(results)

main()

6. 使用`trio`实现异步TCP服务器：

import trio

async def handle_client(stream):
    data = await stream.receive_some(1024)
    await stream.send_all(data.upper())
    await stream.aclose()

async def main():
    await trio.serve_tcp(handle_client, port=8000)

trio.run(main)

7. 使用`asyncio`实现定时任务：

import asyncio

async def task():
    while True:
        print("Running task")
        await asyncio.sleep(1)

async def main():
    await asyncio.gather(task(), asyncio.sleep(5))

asyncio.run(main())

8. 使用`gevent`实现并发数据库访问：

import gevent
from gevent import monkey
from gevent.pool import Pool
import psycopg2

monkey.patch_all()

def fetch_data(query):
    conn = psycopg2.connect("dbname=mydatabase user=myuser password=mypassword")
    cursor = conn.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    cursor.close()
    conn.close()
    return results

def main():
    queries = [
        "SELECT * FROM table1",
        "SELECT * FROM table2",
        "SELECT * FROM table3"
    ]
    pool = Pool(10)
    results = pool.map(fetch_data, queries)
    print(results)

main()

9. 使用`trio`实现异步HTTP服务器：

import trio
from trio_web import serve_websocket, ConnectionClosed

async def handle_websocket(request):
    ws = await request.accept()
    try:
        while True:
            message = await ws.receive_message()
            await ws.send_message(message)
    except ConnectionClosed:
        pass

async def main():
    await serve_websocket(handle_websocket, "0.0.0.0", 8000, ssl_context=None)

trio.run(main)

10. 使用`asyncio`实现异步任务队列：

import asyncio
import random

async def worker(name, queue):
    while True:
        task = await queue.get()
        if task is None:
            break
        print(f"Worker {name} got task: {task}")
        await asyncio.sleep(random.random())

async def main():
    queue = asyncio.Queue()
    workers = [worker("A", queue), worker("B", queue), worker("C", queue)]
    tasks = [f"Task {i}" for i in range(10)]
    random.shuffle(tasks)
    for task in tasks:
        await queue.put(task)
    for _ in workers:
        await queue.put(None)
    await asyncio.gather(*workers)

asyncio.run(main())

这些场景代码展示了`asyncio`、`gevent`和`trio`在异步编程中的应用。它们提供了不同的并发编程模型和工具，适用于不同的应用场景。您可以根据具体需求选择适合的协程库来实现异步操作，并提高程序的性能和并发能力。

希望这些示例代码能够帮助您理解协程库的使用和在异步编程中的应用。如果您有任何进一步的问题，请随时提问。

---------------------------END---------------------------