第十一章 协程和异步IO

目录

12.1 并发、并行、同步、异步、阻塞、非阻塞

并发与并行

同步与异步

阻塞与非阻塞

12.2 C10K问题和I/O多路复用（select、poll、epoll）

C10K问题

I/O多路复用

12.3 epoll + 回调 + 事件循环方式tul

epoll

回调

事件循环

12.4 回调之痛

示例代码：

12.5 C10M问题和协程

C10M问题

协程

12.6 生成器的send和yield from

示例代码：

12.7 生成器如何变成协程？

示例代码：

12.8 async和await原生协程

示例代码：

12.9 本章小结

---

在现代计算中，高效处理I/O操作和并发任务是提升性能的重要手段。Python提供了多种机制来实现并发和异步I/O，包括线程、进程、协程和异步编程。本章将深入探讨这些概念，特别是协程和异步I/O，及其在Python中的实现。

12.1 并发、并行、同步、异步、阻塞、非阻塞

并发与并行

• 并发：指多个任务在同一时间段内交替进行，但不一定同时执行。主要用于处理I/O密集型任务。
• 并行：指多个任务在同一时刻同时执行，通常需要多核CPU支持。适用于CPU密集型任务。

同步与异步

• 同步：任务按顺序执行，一个任务未完成前，后续任务必须等待。
• 异步：任务可以在等待某些操作完成时，继续执行其他任务，不必按顺序执行。

阻塞与非阻塞

• 阻塞：调用某些操作时，必须等待操作完成，期间无法执行其他任务。
• 非阻塞：调用某些操作时，立即返回，可以继续执行其他任务，不必等待操作完成。

12.2 C10K问题和I/O多路复用（select、poll、epoll）

C10K问题

C10K问题指的是在单台服务器上同时处理1万个客户端连接的问题。这一挑战要求服务器具备高并发处理能力，传统的线程或进程模型难以满足这一需求。

I/O多路复用

I/O多路复用是解决C10K问题的关键技术，通过单个线程监视多个I/O描述符，并在某个描述符准备好进行I/O操作时进行处理。常见的方法有select、poll和epoll。

• select：最早的I/O多路复用技术，但在文件描述符数量较多时性能下降。
• poll：类似于select，但没有文件描述符数量的限制。
• epoll：Linux特有的I/O多路复用技术，性能优越，适用于大规模并发连接。

示例代码：

import select
import socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 8080))
server_socket.listen()

sockets_list = [server_socket]
clients = {}

while True:
    read_sockets, _, _ = select.select(sockets_list, [], [])
    for notified_socket in read_sockets:
        if notified_socket == server_socket:
            client_socket, client_address = server_socket.accept()
            sockets_list.append(client_socket)
            clients[client_socket] = client_address
        else:
            message = notified_socket.recv(1024)
            if message:
                print(f"Received message from {clients[notified_socket]}: {message.decode('utf-8')}")
            else:
                sockets_list.remove(notified_socket)
                del clients[notified_socket]
                notified_socket.close()

12.3 epoll + 回调 + 事件循环方式tul

epoll

epoll是Linux下高效的I/O多路复用技术，支持水平触发和边缘触发模式。与select和poll相比，epoll在大量并发连接时性能更佳。

回调

回调函数是一种异步编程技术，通过将函数作为参数传递，允许在某个事件发生时调用该函数。

事件循环

事件循环是异步编程的核心，通过不断检查和调度任务执行，处理异步I/O事件和回调。

示例代码：

import selectors
import socket

selector = selectors.DefaultSelector()

def accept_wrapper(sock):
    conn, addr = sock.accept()
    print(f"Accepted connection from {addr}")
    conn.setblocking(False)
    data = types.SimpleNamespace(addr=addr, inb=b'', outb=b'')
    events = selectors.EVENT_READ | selectors.EVENT_WRITE
    selector.register(conn, events, data=data)

def service_connection(key, mask):
    sock = key.fileobj
    data = key.data
    if mask & selectors.EVENT_READ:
        recv_data = sock.recv(1024)
        if recv_data:
            data.outb += recv_data
        else:
            print(f"Closing connection to {data.addr}")
            selector.unregister(sock)
            sock.close()
    if mask & selectors.EVENT_WRITE:
        if data.outb:
            sent = sock.send(data.outb)
            data.outb = data.outb[sent:]

lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
lsock.bind(('localhost', 8080))
lsock.listen()
lsock.setblocking(False)
selector.register(lsock, selectors.EVENT_READ, data=None)

while True:
    events = selector.select(timeout=None)
    for key, mask in events:
        if key.data is None:
            accept_wrapper(key.fileobj)
        else:
            service_connection(key, mask)

12.4 回调之痛

尽管回调是一种强大的异步编程方式，但它也带来了代码难以理解和维护的问题，常称为“回调地狱”。随着回调的嵌套层数增加，代码的可读性和可维护性急剧下降。

示例代码：

def fetch_data(callback):
    def on_data_fetched(data):
        callback(data)
    
    # 模拟异步数据获取
    on_data_fetched("some data")

def process_data(data, callback):
    def on_data_processed(result):
        callback(result)
    
    # 模拟数据处理
    on_data_processed(data.upper())

def save_data(result, callback):
    def on_data_saved():
        callback()
    
    # 模拟数据保存
    on_data_saved()

def main():
    fetch_data(lambda data: 
               process_data(data, lambda result: 
                            save_data(result, lambda: 
                                     print("All done"))))

main()

12.5 C10M问题和协程

C10M问题

C10M问题是C10K问题的进一步挑战，指的是在单台服务器上同时处理1000万个客户端连接。为了解决这一问题，需要更加高效的并发处理方式。

协程

协程是比线程更轻量级的并发单元，通过在函数执行过程中挂起和恢复，实现高效的协作式多任务处理。Python中的asyncio库提供了对协程的支持。

示例代码：

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    print(f"Received {message}")
    writer.write(data)
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(handle_client, 'localhost', 8080)
    async with server:
        await server.serve_forever()

asyncio.run(main())

12.6 生成器的send和yield from

生成器不仅可以通过yield产生值，还可以通过send接收外部值。yield from用于委托生成器，简化生成器的嵌套调用。

示例代码：

def generator():
    value = yield "Initial value"
    print(f"Received: {value}")
    yield "Final value"

gen = generator()
print(next(gen))  # 输出：Initial value
print(gen.send(42))  # 输出：Received: 42, Final value

yield from

def generator1():
    yield from range(3)
    yield from "abc"

gen = generator1()
for value in gen:
    print(value)

12.7 生成器如何变成协程？

生成器可以通过使用async和await关键字转换为协程，从而支持异步操作。

示例代码：

async def async_generator():
    for i in range(3):
        yield i
        await asyncio.sleep(1)

async def main():
    async for value in async_generator():
        print(value)

asyncio.run(main())

12.8 async和await原生协程

async和await是Python 3.5引入的用于定义和操作协程的关键字，使得异步编程更加直观和易读。

示例代码：

import asyncio

async def say_hello():
    await asyncio.sleep(1)
    print("Hello")

async def main():
    await say_hello()
    print("World")

asyncio.run(main())

12.9 本章小结

在本章中，我们深入探讨了Python中的协程和异步I/O，包括并发和并行的区别、同步和异步的概念、阻塞和非阻塞的区别。我们了解了C10K和C10M问题，并探讨了I/O多路复用技术，如select、poll和epoll。我们还详细介绍了回调函数和事件循环的实现，并讨论了回调地狱的问题。最后，我们学习了生成器和协程的高级用法，包括send、yield from、async和await关键字的使用。

通过这些内容，读者可以更深入地理解Python中的并发和异步编程模型，掌握如何使用协程和异步I/O来编写高效的代码。如果您有任何进一步的问题或需要更详细的解释，请随时告诉我！