深入探讨操作系统的IO模型：从同步到异步

需要重新演唱

于 2024-10-04 05:00:00 发布

阅读量837

点赞数 5

文章标签：操作系统

本文链接：https://blog.csdn.net/xycxycooo/article/details/142629014

版权

深入探讨操作系统的IO模型：从同步到异步

在现代编程中，IO操作（输入/输出）是不可避免的。无论是读取文件、网络通信还是数据库查询，IO操作的效率直接影响到应用程序的性能。为了更好地理解和优化这些操作，了解操作系统的IO模型是至关重要的。本文将深入探讨几种常见的IO模型，并通过代码示例帮助你更好地理解它们的原理和应用。

1. 前置知识：什么是IO操作？

在开始之前，我们需要明确什么是IO操作。简单来说，IO操作是指计算机系统与外部设备（如磁盘、网络、键盘、显示器等）之间的数据交换。这些操作通常是阻塞的，即程序在执行IO操作时会暂停，直到操作完成。

2. 同步阻塞IO（Synchronous Blocking IO）

同步阻塞IO是最简单、最直观的IO模型。在这种模型中，当一个线程发起一个IO操作时，它会一直等待，直到操作完成。这种模型的优点是简单易懂，缺点是效率低下，尤其是在高并发场景下。

代码示例：

import socket

def blocking_io():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('localhost', 8080))
    server_socket.listen(5)

    print("Server is listening on port 8080...")

    while True:
        client_socket, addr = server_socket.accept()  # 阻塞，直到有客户端连接
        print(f"Connection from {addr}")

        data = client_socket.recv(1024)  # 阻塞，直到接收到数据
        print(f"Received data: {data.decode()}")

        client_socket.send(data)  # 阻塞，直到数据发送完成
        client_socket.close()

if __name__ == "__main__":
    blocking_io()

解释：

accept() 和 recv() 方法都是阻塞的，这意味着程序会在这里暂停，直到有客户端连接或数据到达。
这种模型适用于简单的应用场景，但在高并发环境下，会导致大量的线程被阻塞，浪费系统资源。

3. 同步非阻塞IO（Synchronous Non-blocking IO）

同步非阻塞IO允许程序在发起IO操作后继续执行其他任务，而不是等待操作完成。通过轮询（polling）的方式，程序可以检查IO操作是否完成。

代码示例：

import socket

def non_blocking_io():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('localhost', 8080))
    server_socket.listen(5)
    server_socket.setblocking(False)  # 设置为非阻塞模式

    print("Server is listening on port 8080...")

    while True:
        try:
            client_socket, addr = server_socket.accept()  # 非阻塞，如果没有连接会抛出异常
            client_socket.setblocking(False)  # 设置客户端socket为非阻塞
            print(f"Connection from {addr}")

            while True:
                try:
                    data = client_socket.recv(1024)  # 非阻塞，如果没有数据会抛出异常
                    if data:
                        print(f"Received data: {data.decode()}")
                        client_socket.send(data)
                    else:
                        client_socket.close()
                        break
                except BlockingIOError:
                    continue
        except BlockingIOError:
            continue

if __name__ == "__main__":
    non_blocking_io()

解释：

setblocking(False) 将socket设置为非阻塞模式。
accept() 和 recv() 方法在没有连接或数据时会抛出 BlockingIOError 异常，程序通过捕获异常来继续执行其他任务。
非阻塞IO虽然提高了程序的响应速度，但需要频繁轮询，增加了CPU的负担。

4. IO复用模型（IO Multiplexing）

IO复用是一种更高效的IO模型，它允许单个线程同时监视多个IO操作。常见的实现方式有 select、poll 和 epoll。

代码示例（使用 select）：

import select
import socket

def io_multiplexing():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('localhost', 8080))
    server_socket.listen(5)
    server_socket.setblocking(False)

    inputs = [server_socket]
    outputs = []

    print("Server is listening on port 8080...")

    while True:
        readable, writable, exceptional = select.select(inputs, outputs, inputs)

        for s in readable:
            if s is server_socket:
                client_socket, addr = s.accept()
                client_socket.setblocking(False)
                inputs.append(client_socket)
                print(f"Connection from {addr}")
            else:
                data = s.recv(1024)
                if data:
                    print(f"Received data: {data.decode()}")
                    if s not in outputs:
                        outputs.append(s)
                else:
                    if s in outputs:
                        outputs.remove(s)
                    inputs.remove(s)
                    s.close()

        for s in writable:
            s.send(b"ACK")
            outputs.remove(s)

        for s in exceptional:
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()

if __name__ == "__main__":
    io_multiplexing()

解释：

select.select() 方法监视多个socket，返回可读、可写和异常的socket列表。
通过这种方式，单个线程可以同时处理多个IO操作，提高了系统的并发能力。

5. 信号驱动IO模型（Signal-driven IO）

信号驱动IO是一种基于信号的IO模型，当IO操作完成时，操作系统会发送一个信号通知应用程序。这种模型在Linux系统中较为常见。

代码示例（使用 sigaction）：

#include <stdio.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>

void io_handler(int sig) {
    char buffer[1024];
    int bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer));
    if (bytes_read > 0) {
        printf("Received data: %s\n", buffer);
    }
}

int main() {
    struct sigaction sa;
    sa.sa_handler = io_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    sigaction(SIGIO, &sa, NULL);

    fcntl(STDIN_FILENO, F_SETOWN, getpid());
    fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL) | O_ASYNC);

    while (1) {
        sleep(1);
    }

    return 0;
}

解释：

sigaction 结构体用于设置信号处理函数。
fcntl 函数用于设置文件描述符的属性和状态。
当标准输入有数据时，操作系统会发送 SIGIO 信号，触发 io_handler 函数。

6. 异步IO模型（Asynchronous IO）

异步IO是最先进的IO模型，它允许应用程序在发起IO操作后立即返回，并在操作完成时通过回调函数或事件通知应用程序。

代码示例（使用 asyncio 库）：

import asyncio

async def handle_client(reader, writer):
    data = await reader.read(1024)
    message = data.decode()
    addr = writer.get_extra_info('peername')
    print(f"Received {message} from {addr}")

    writer.write(data)
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(handle_client, 'localhost', 8080)
    print("Server is listening on port 8080...")

    async with server:
        await server.serve_forever()

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