MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

深入理解网络编程中的I/O模型与多路复用技术

2022-08-194.7k 阅读

网络编程基础

在深入探讨 I/O 模型与多路复用技术之前，我们先来回顾一下网络编程的基础知识。网络编程主要涉及在不同设备之间通过网络协议进行数据传输和交互。在网络编程中，我们通常使用套接字（Socket）来实现进程间的网络通信。

套接字（Socket）

套接字是一种抽象层，它为应用程序提供了一种访问网络服务的方式。它可以看作是两个进程之间通信的端点。在 Unix 系统中，套接字被视为一种特殊的文件描述符，这意味着我们可以使用传统的文件 I/O 操作（如 read 和 write）来与套接字进行交互。

在 Python 中，使用 socket 模块来创建和操作套接字。以下是一个简单的 TCP 服务器示例：

import socket

# 创建一个 TCP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定到指定地址和端口
server_socket.bind(('127.0.0.1', 8888))

# 开始监听
server_socket.listen(5)

print('Server is listening on port 8888')

while True:
    # 接受客户端连接
    client_socket, client_address = server_socket.accept()
    print(f'Connected by {client_address}')

    # 接收数据
    data = client_socket.recv(1024)
    print(f'Received: {data.decode()}')

    # 发送响应
    response = 'Message received successfully'.encode()
    client_socket.send(response)

    # 关闭客户端套接字
    client_socket.close()

在这个示例中，我们创建了一个 TCP 套接字，绑定到本地地址 127.0.0.1 和端口 8888，然后开始监听连接。当有客户端连接时，我们接收客户端发送的数据，并回显一个响应。

网络协议

网络编程中涉及多种网络协议，其中最常用的是 TCP（传输控制协议）和 UDP（用户数据报协议）。

  • TCP：是一种面向连接的、可靠的传输协议。它通过三次握手建立连接，保证数据的有序传输和完整性。TCP 适用于对数据准确性要求较高的应用，如文件传输、电子邮件等。

  • UDP：是一种无连接的、不可靠的传输协议。它不保证数据的有序传输和完整性，但具有较低的延迟和开销。UDP 适用于对实时性要求较高的应用，如视频流、音频流等。

I/O 模型

I/O 模型定义了应用程序与操作系统之间进行 I/O 操作的方式。在网络编程中，I/O 操作主要涉及从套接字读取数据和向套接字写入数据。常见的 I/O 模型有以下几种：

阻塞 I/O 模型（Blocking I/O）

在阻塞 I/O 模型中，当应用程序调用 I/O 操作（如 recv 或 send）时，线程会被阻塞，直到操作完成。以之前的 TCP 服务器为例，当调用 recv 方法时，线程会等待客户端发送数据，在数据到达之前，线程无法执行其他任务。

这种模型的优点是简单直观，缺点是在 I/O 操作阻塞期间，线程无法处理其他任务，导致 CPU 资源浪费。特别是在处理多个客户端连接时，每个连接都需要一个独立的线程来处理 I/O 操作，这会导致线程数量过多，消耗大量系统资源。

非阻塞 I/O 模型（Non - blocking I/O）

非阻塞 I/O 模型中，当应用程序调用 I/O 操作时，无论操作是否完成，函数都会立即返回。如果操作尚未完成，函数会返回一个错误码（如 EWOULDBLOCK）。应用程序需要不断地轮询检查 I/O 操作是否完成。

以下是一个使用非阻塞套接字的简单示例：

import socket
import time

# 创建一个 TCP 套接字并设置为非阻塞模式
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setblocking(False)

# 绑定到指定地址和端口
server_socket.bind(('127.0.0.1', 8888))

# 开始监听
server_socket.listen(5)

print('Server is listening on port 8888')

while True:
    try:
        # 接受客户端连接
        client_socket, client_address = server_socket.accept()
        print(f'Connected by {client_address}')
        client_socket.setblocking(False)
    except BlockingIOError:
        pass

    try:
        for client in [client_socket]:
            try:
                # 接收数据
                data = client.recv(1024)
                if data:
                    print(f'Received: {data.decode()}')
                    # 发送响应
                    response = 'Message received successfully'.encode()
                    client.send(response)
            except BlockingIOError:
                pass
    except NameError:
        pass

    time.sleep(0.1)

在这个示例中，我们将套接字设置为非阻塞模式。在接受连接和接收数据时，如果操作尚未准备好，会捕获 BlockingIOError 异常并继续执行。这种模型虽然不会阻塞线程，但需要不断轮询，会消耗大量 CPU 资源。

I/O 多路复用模型（I/O Multiplexing）

I/O 多路复用模型通过一个进程监视多个文件描述符（如套接字），当其中任何一个文件描述符准备好进行 I/O 操作时，通知应用程序进行相应处理。这种模型可以在一个线程内处理多个 I/O 操作，提高了资源利用率。常见的 I/O 多路复用技术有 select、poll 和 epoll。

I/O 多路复用技术

select

select 是最早的 I/O 多路复用技术，它通过 select 函数来监视一组文件描述符。select 函数的原型如下：

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

其中，nfds 是需要监视的文件描述符集合中最大的文件描述符值加 1。readfds、writefds 和 exceptfds 分别是需要监视读、写和异常事件的文件描述符集合。timeout 是等待的超时时间。

以下是一个使用 select 的简单示例（以 Python 为例）：

import socket
import select

# 创建一个 TCP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定到指定地址和端口
server_socket.bind(('127.0.0.1', 8888))

# 开始监听
server_socket.listen(5)

print('Server is listening on port 8888')

# 用于监视读事件的文件描述符集合
read_fds = {server_socket}

while True:
    # 使用 select 监视文件描述符集合
    ready_fds, _, _ = select.select(read_fds, [], [])

    for fd in ready_fds:
        if fd is server_socket:
            # 有新的客户端连接
            client_socket, client_address = server_socket.accept()
            print(f'Connected by {client_address}')
            read_fds.add(client_socket)
        else:
            # 有数据可读
            data = fd.recv(1024)
            if data:
                print(f'Received: {data.decode()}')
                # 发送响应
                response = 'Message received successfully'.encode()
                fd.send(response)
            else:
                # 客户端关闭连接
                read_fds.remove(fd)
                fd.close()

在这个示例中，我们使用 select 函数监视 server_socket 和已连接的 client_socket。当有新的连接或数据可读时，select 会返回相应的文件描述符，我们再进行相应的处理。

select 的缺点是：

  1. 监视的文件描述符数量有限制，通常为 1024 个。
  2. 每次调用 select 时，都需要将文件描述符集合从用户空间复制到内核空间，性能开销较大。

poll

poll 是对 select 的改进，它使用 pollfd 结构体数组来代替 select 中的文件描述符集合。poll 函数的原型如下：

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

其中，fds 是 pollfd 结构体数组，nfds 是数组中元素的数量，timeout 是等待的超时时间。

以下是一个使用 poll 的简单示例（以 Python 为例，Python 中没有直接的 poll 接口，我们使用 select.poll 来模拟）：

import socket
import select

# 创建一个 TCP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定到指定地址和端口
server_socket.bind(('127.0.0.1', 8888))

# 开始监听
server_socket.listen(5)

print('Server is listening on port 8888')

# 创建 poll 对象
poll_obj = select.poll()

# 注册 server_socket 为可读事件
poll_obj.register(server_socket, select.POLLIN)

fd_to_socket = {server_socket.fileno(): server_socket}

while True:
    # 使用 poll 监视文件描述符
    events = poll_obj.poll()

    for fd, event in events:
        sock = fd_to_socket[fd]
        if sock is server_socket:
            # 有新的客户端连接
            client_socket, client_address = server_socket.accept()
            print(f'Connected by {client_address}')
            # 注册新的客户端套接字为可读事件
            poll_obj.register(client_socket, select.POLLIN)
            fd_to_socket[client_socket.fileno()] = client_socket
        else:
            # 有数据可读
            data = sock.recv(1024)
            if data:
                print(f'Received: {data.decode()}')
                # 发送响应
                response = 'Message received successfully'.encode()
                sock.send(response)
            else:
                # 客户端关闭连接
                poll_obj.unregister(sock)
                del fd_to_socket[fd]
                sock.close()

poll 相对于 select 的优点是：

  1. 没有文件描述符数量的限制。
  2. 性能有所提升，因为 poll 传递的是结构体数组，不需要像 select 那样每次都复制整个文件描述符集合。

epoll

epoll 是 Linux 特有的 I/O 多路复用技术，它在性能和可扩展性方面都优于 select 和 poll。epoll 使用事件驱动的方式，当文件描述符上有事件发生时，内核会将事件通知给应用程序。

epoll 有两种工作模式：

  1. 水平触发（LT - Level Triggered）：默认模式，当文件描述符上有数据可读或可写时，会不断通知应用程序，直到数据被处理完。
  2. 边缘触发（ET - Edge Triggered）：当文件描述符状态发生变化时，只通知一次应用程序。这种模式要求应用程序在收到通知后尽可能多地处理数据，以避免错过事件。

以下是一个使用 epoll 的简单示例（以 Python 为例，Python 中通过 select.epoll 来使用 epoll）：

import socket
import select

# 创建一个 TCP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定到指定地址和端口
server_socket.bind(('127.0.0.1', 8888))

# 开始监听
server_socket.listen(5)

print('Server is listening on port 8888')

# 创建 epoll 对象
epoll_obj = select.epoll()

# 注册 server_socket 为可读事件
epoll_obj.register(server_socket.fileno(), select.EPOLLIN)

fd_to_socket = {server_socket.fileno(): server_socket}

while True:
    # 使用 epoll 监视文件描述符
    events = epoll_obj.poll()

    for fd, event in events:
        sock = fd_to_socket[fd]
        if sock is server_socket:
            # 有新的客户端连接
            client_socket, client_address = server_socket.accept()
            print(f'Connected by {client_address}')
            # 设置为非阻塞模式
            client_socket.setblocking(False)
            # 注册新的客户端套接字为可读事件，使用边缘触发模式
            epoll_obj.register(client_socket.fileno(), select.EPOLLIN | select.EPOLLET)
            fd_to_socket[client_socket.fileno()] = client_socket
        else:
            # 有数据可读
            data = sock.recv(1024)
            if data:
                print(f'Received: {data.decode()}')
                # 发送响应
                response = 'Message received successfully'.encode()
                sock.send(response)
            else:
                # 客户端关闭连接
                epoll_obj.unregister(sock.fileno())
                del fd_to_socket[fd]
                sock.close()

在这个示例中，我们使用 epoll 来监视文件描述符。当有新连接时，将新的客户端套接字注册到 epoll 中，并设置为非阻塞模式和边缘触发模式。当有数据可读时，进行相应的处理。

epoll 的优点：

  1. 性能更高，因为它采用事件驱动的方式，避免了像 select 和 poll 那样每次都需要遍历所有文件描述符。
  2. 支持大量的文件描述符，理论上没有限制。

异步 I/O 模型（Asynchronous I/O）

异步 I/O 模型中，应用程序调用 I/O 操作后，无需等待操作完成，立即返回。当 I/O 操作完成后，操作系统会以回调函数或信号的方式通知应用程序。这种模型可以最大程度地提高系统的并发性能。

在 Linux 中，aio 系列函数提供了异步 I/O 的支持。以下是一个简单的异步 I/O 示例（以 C 语言为例）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <aio.h>

#define BUFFER_SIZE 1024

void io_callback(sigval_t sigval) {
    struct aiocb *io = (struct aiocb *)sigval.sival_ptr;
    ssize_t ret = aio_return(io);
    if (ret > 0) {
        printf("Read %zd bytes\n", ret);
    } else {
        perror("aio_return");
    }
    free(io);
}

int main() {
    int fd = open("test.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    struct aiocb *io = (struct aiocb *)malloc(sizeof(struct aiocb));
    if (!io) {
        perror("malloc");
        close(fd);
        return 1;
    }

    char buffer[BUFFER_SIZE];
    io->aio_fildes = fd;
    io->aio_buf = buffer;
    io->aio_nbytes = BUFFER_SIZE;
    io->aio_offset = 0;
    io->aio_sigevent.sigev_notify = SIGEV_THREAD;
    io->aio_sigevent.sigev_notify_function = io_callback;
    io->aio_sigevent.sigev_value.sival_ptr = io;

    if (aio_read(io) == -1) {
        perror("aio_read");
        free(io);
        close(fd);
        return 1;
    }

    // 可以继续执行其他任务
    sleep(2);

    free(io);
    close(fd);
    return 0;
}

在这个示例中，我们使用 aio_read 进行异步读操作，并通过 io_callback 函数在操作完成后进行处理。

异步 I/O 模型的优点是可以在 I/O 操作进行的同时，让应用程序继续执行其他任务，提高了系统的并发性能。缺点是编程模型相对复杂，需要处理回调函数或信号等机制。

总结与比较

不同的 I/O 模型和多路复用技术各有优缺点，在实际应用中需要根据具体需求选择合适的模型。

I/O 模型/技术优点缺点
阻塞 I/O简单直观线程阻塞，资源利用率低
非阻塞 I/O不会阻塞线程轮询消耗大量 CPU 资源
select跨平台支持文件描述符数量有限，性能开销大
poll无文件描述符数量限制，性能优于 select每次仍需遍历所有文件描述符
epoll高性能，支持大量文件描述符仅 Linux 平台支持
异步 I/O高并发性能编程模型复杂

希望通过本文的介绍，你对网络编程中的 I/O 模型与多路复用技术有了更深入的理解，并能在实际项目中根据需求选择合适的技术方案。