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

Linux C语言非阻塞I/O的事件驱动

2023-09-231.7k 阅读

1. 理解 Linux 中的 I/O 模型

在深入探讨非阻塞 I/O 的事件驱动之前，我们需要对 Linux 中的 I/O 模型有一个基本的了解。常见的 I/O 模型包括阻塞 I/O、非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O。

1.1 阻塞 I/O

阻塞 I/O 是最基本的 I/O 模型。当一个应用程序执行一个 I/O 操作（如读或写）时，内核会将进程置于睡眠状态，直到 I/O 操作完成。例如，当使用 read 系统调用从文件描述符读取数据时，如果数据尚未准备好，进程会一直等待，直到数据可用。以下是一个简单的阻塞 I/O 读操作的代码示例：

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

#define BUFFER_SIZE 1024

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

    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        perror("read");
        close(fd);
        return 1;
    }

    buffer[bytes_read] = '\0';
    printf("Read data: %s\n", buffer);
    close(fd);
    return 0;
}

在这个例子中，如果 example.txt 文件中的数据尚未准备好，read 调用会阻塞进程，直到数据可读。

1.2 非阻塞 I/O

非阻塞 I/O 允许应用程序在 I/O 操作未准备好时，不会阻塞进程，而是立即返回一个错误（通常是 EAGAIN 或 EWOULDBLOCK）。应用程序可以继续执行其他任务，然后稍后再次尝试 I/O 操作。要将文件描述符设置为非阻塞模式，可以使用 fcntl 函数。以下是一个将文件描述符设置为非阻塞模式并进行读操作的示例：

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

#define BUFFER_SIZE 1024

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

    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl F_GETFL");
        close(fd);
        return 1;
    }

    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL");
        close(fd);
        return 1;
    }

    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("Data is not ready yet. Try again later.\n");
        } else {
            perror("read");
        }
    } else {
        buffer[bytes_read] = '\0';
        printf("Read data: %s\n", buffer);
    }

    close(fd);
    return 0;
}

在这个示例中，我们首先通过 fcntl 获取文件描述符的当前标志，然后添加 O_NONBLOCK 标志将其设置为非阻塞模式。如果 read 调用返回 -1 且错误码为 EAGAIN 或 EWOULDBLOCK，表示数据尚未准备好，应用程序可以稍后再次尝试读取。

2. 事件驱动编程模型

事件驱动编程是一种编程范式，其中程序的执行流程由事件（如 I/O 事件、信号等）驱动。在这种模型中，应用程序通常会注册回调函数来处理不同类型的事件。当一个事件发生时，系统会调用相应的回调函数，从而执行与该事件相关的操作。

2.1 事件驱动的优势

事件驱动编程模型具有以下几个优势：

  • 高效利用资源：与传统的多线程或多进程模型相比，事件驱动模型不需要为每个 I/O 操作创建新的线程或进程，从而减少了系统资源的开销。
  • 更好的并发处理能力：事件驱动模型可以在单线程内处理多个并发的 I/O 操作，通过事件循环和回调函数，有效地管理多个 I/O 流。
  • 简单的编程模型：事件驱动编程模型通过回调函数的方式，将复杂的异步操作分解为多个简单的事件处理函数，使得代码结构更加清晰，易于维护。

2.2 事件驱动的组成部分

一个典型的事件驱动系统通常由以下几个部分组成：

  • 事件源：产生事件的对象，如文件描述符（表示 I/O 操作）、信号等。
  • 事件多路复用器：负责监听多个事件源的状态变化，并在有事件发生时通知应用程序。在 Linux 中，常见的事件多路复用器有 select、poll 和 epoll。
  • 事件循环：一个无限循环，不断地检查事件多路复用器，获取发生的事件，并调用相应的回调函数进行处理。
  • 回调函数：与特定事件相关联的函数，当该事件发生时，由事件循环调用，执行具体的处理逻辑。

3. Linux 中的事件多路复用器

在 Linux 中，有几种不同的事件多路复用器可供选择，每种都有其特点和适用场景。

3.1 select

select 是最古老的事件多路复用机制之一。它允许应用程序监听多个文件描述符的状态变化，包括读、写和异常事件。select 的函数原型如下：

#include <sys/select.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
  • nfds：需要检查的文件描述符集中最大文件描述符的值加 1。
  • readfds、writefds、exceptfds：分别是读、写和异常事件的文件描述符集合。
  • timeout：指定等待的超时时间，如果为 NULL，则一直阻塞，直到有事件发生。

以下是一个使用 select 实现简单 I/O 多路复用的示例：

#include <stdio.h>
#include <sys/select.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

#define BUFFER_SIZE 1024

void handle_read(int fd) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        perror("read");
    } else if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("Read data: %s\n", buffer);
    }
}

int main() {
    int fd1 = open("file1.txt", O_RDONLY);
    int fd2 = open("file2.txt", O_RDONLY);
    if (fd1 == -1 || fd2 == -1) {
        perror("open");
        return 1;
    }

    fd_set read_fds;
    FD_ZERO(&read_fds);
    FD_SET(fd1, &read_fds);
    FD_SET(fd2, &read_fds);

    int max_fd = (fd1 > fd2? fd1 : fd2) + 1;

    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;

    int activity = select(max_fd, &read_fds, NULL, NULL, &timeout);
    if (activity == -1) {
        perror("select");
    } else if (activity > 0) {
        if (FD_ISSET(fd1, &read_fds)) {
            handle_read(fd1);
        }
        if (FD_ISSET(fd2, &read_fds)) {
            handle_read(fd2);
        }
    } else {
        printf("Timeout occurred.\n");
    }

    close(fd1);
    close(fd2);
    return 0;
}

在这个示例中，我们使用 select 监听两个文件描述符 fd1 和 fd2 的读事件。如果有任何一个文件描述符可读，select 会返回，并通过 FD_ISSET 宏检查具体是哪个文件描述符发生了事件，然后调用 handle_read 函数进行处理。

3.2 poll

poll 是 select 的改进版本，它使用一个 pollfd 结构体数组来表示需要监听的文件描述符及其事件。poll 的函数原型如下：

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  • fds：一个 pollfd 结构体数组，每个结构体包含一个文件描述符、需要监听的事件和发生的事件。
  • nfds：数组中元素的数量。
  • timeout：等待的超时时间，单位是毫秒。如果为 -1，则一直阻塞；如果为 0，则立即返回。

以下是一个使用 poll 的示例：

#include <stdio.h>
#include <poll.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

#define BUFFER_SIZE 1024

void handle_read(int fd) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        perror("read");
    } else if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("Read data: %s\n", buffer);
    }
}

int main() {
    int fd1 = open("file1.txt", O_RDONLY);
    int fd2 = open("file2.txt", O_RDONLY);
    if (fd1 == -1 || fd2 == -1) {
        perror("open");
        return 1;
    }

    struct pollfd fds[2];
    fds[0].fd = fd1;
    fds[0].events = POLLIN;
    fds[1].fd = fd2;
    fds[1].events = POLLIN;

    int activity = poll(fds, 2, 5000);
    if (activity == -1) {
        perror("poll");
    } else if (activity > 0) {
        if (fds[0].revents & POLLIN) {
            handle_read(fd1);
        }
        if (fds[1].revents & POLLIN) {
            handle_read(fd2);
        }
    } else {
        printf("Timeout occurred.\n");
    }

    close(fd1);
    close(fd2);
    return 0;
}

在这个示例中，我们创建了一个 pollfd 数组，分别设置了两个文件描述符的读事件。poll 返回后，通过检查 revents 字段来确定发生了哪些事件，并调用相应的处理函数。

3.3 epoll

epoll 是 Linux 特有的高性能事件多路复用机制，适用于处理大量并发连接的场景。epoll 有两种工作模式：水平触发（LT）和边缘触发（ET）。水平触发模式下，只要文件描述符上有未处理的事件，epoll_wait 就会一直返回；边缘触发模式下，只有当文件描述符状态发生变化时，epoll_wait 才会返回。

epoll 使用以下几个函数：

#include <sys/epoll.h>

// 创建一个 epoll 实例
int epoll_create(int size);

// 控制 epoll 实例中要监听的文件描述符
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

// 等待事件发生
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

以下是一个使用 epoll 的示例：

#include <stdio.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>

#define BUFFER_SIZE 1024
#define MAX_EVENTS 10

void handle_read(int fd) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        perror("read");
    } else if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("Read data: %s\n", buffer);
    }
}

int main() {
    int epfd = epoll_create(MAX_EVENTS);
    if (epfd == -1) {
        perror("epoll_create");
        return 1;
    }

    int fd1 = open("file1.txt", O_RDONLY);
    int fd2 = open("file2.txt", O_RDONLY);
    if (fd1 == -1 || fd2 == -1) {
        perror("open");
        close(epfd);
        return 1;
    }

    struct epoll_event event;
    event.data.fd = fd1;
    event.events = EPOLLIN;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd1, &event) == -1) {
        perror("epoll_ctl add fd1");
        close(epfd);
        close(fd1);
        close(fd2);
        return 1;
    }

    event.data.fd = fd2;
    event.events = EPOLLIN;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd2, &event) == -1) {
        perror("epoll_ctl add fd2");
        close(epfd);
        close(fd1);
        close(fd2);
        return 1;
    }

    struct epoll_event events[MAX_EVENTS];
    int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
    if (n == -1) {
        perror("epoll_wait");
        close(epfd);
        close(fd1);
        close(fd2);
        return 1;
    }

    for (int i = 0; i < n; ++i) {
        if (events[i].events & EPOLLIN) {
            handle_read(events[i].data.fd);
        }
    }

    close(epfd);
    close(fd1);
    close(fd2);
    return 0;
}

在这个示例中，我们首先使用 epoll_create 创建一个 epoll 实例，然后通过 epoll_ctl 将两个文件描述符添加到 epoll 实例中，监听读事件。epoll_wait 会阻塞等待事件发生，当有事件发生时，通过检查 events 数组中的事件类型，调用相应的处理函数。

4. 结合非阻塞 I/O 和事件驱动

将非阻塞 I/O 与事件驱动编程模型结合，可以实现高效的并发 I/O 处理。通过事件多路复用器监听多个非阻塞文件描述符的事件，当事件发生时，在回调函数中进行非阻塞 I/O 操作，从而避免阻塞进程，提高系统的并发处理能力。

以下是一个综合示例，使用 epoll 实现非阻塞 I/O 的事件驱动：

#include <stdio.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#define BUFFER_SIZE 1024
#define MAX_EVENTS 10

void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl F_GETFL");
        return;
    }

    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL");
        return;
    }
}

void handle_read(int epfd, int fd) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;
    while ((bytes_read = read(fd, buffer, BUFFER_SIZE)) > 0) {
        buffer[bytes_read] = '\0';
        printf("Read data: %s\n", buffer);
    }

    if (bytes_read == -1 && errno != EAGAIN && errno != EWOULDBLOCK) {
        perror("read");
        struct epoll_event event;
        event.data.fd = fd;
        event.events = EPOLLIN;
        if (epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &event) == -1) {
            perror("epoll_ctl DEL");
        }
        close(fd);
    }
}

int main() {
    int epfd = epoll_create(MAX_EVENTS);
    if (epfd == -1) {
        perror("epoll_create");
        return 1;
    }

    int fd1 = open("file1.txt", O_RDONLY);
    int fd2 = open("file2.txt", O_RDONLY);
    if (fd1 == -1 || fd2 == -1) {
        perror("open");
        close(epfd);
        return 1;
    }

    set_nonblocking(fd1);
    set_nonblocking(fd2);

    struct epoll_event event;
    event.data.fd = fd1;
    event.events = EPOLLIN;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd1, &event) == -1) {
        perror("epoll_ctl add fd1");
        close(epfd);
        close(fd1);
        close(fd2);
        return 1;
    }

    event.data.fd = fd2;
    event.events = EPOLLIN;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd2, &event) == -1) {
        perror("epoll_ctl add fd2");
        close(epfd);
        close(fd1);
        close(fd2);
        return 1;
    }

    struct epoll_event events[MAX_EVENTS];
    int n;
    while ((n = epoll_wait(epfd, events, MAX_EVENTS, -1)) > 0) {
        for (int i = 0; i < n; ++i) {
            if (events[i].events & EPOLLIN) {
                handle_read(epfd, events[i].data.fd);
            }
        }
    }

    if (n == -1) {
        perror("epoll_wait");
    }

    close(epfd);
    close(fd1);
    close(fd2);
    return 0;
}

在这个示例中，我们首先将两个文件描述符设置为非阻塞模式，然后将它们添加到 epoll 实例中监听读事件。当有读事件发生时，handle_read 函数会尝试读取数据，直到数据读完或遇到 EAGAIN 或 EWOULDBLOCK 错误。如果读取过程中发生其他错误，会将文件描述符从 epoll 实例中删除并关闭。通过这种方式，我们实现了非阻塞 I/O 的事件驱动处理，提高了系统的并发 I/O 处理能力。

5. 实际应用场景

非阻塞 I/O 的事件驱动在很多实际应用场景中都有广泛的应用。

5.1 网络服务器

在网络服务器开发中，通常需要同时处理多个客户端的连接。使用非阻塞 I/O 和事件驱动模型，可以避免为每个客户端连接创建一个新的线程或进程，从而减少系统资源的开销。例如，一个基于 TCP 的聊天服务器，可以使用 epoll 监听多个客户端套接字的读、写事件，当有数据可读时，读取数据并进行处理，然后将处理结果发送回客户端。

5.2 高性能 I/O 应用

对于需要处理大量 I/O 操作的应用，如文件服务器、数据库服务器等，非阻塞 I/O 的事件驱动模型可以提高系统的 I/O 性能。通过事件多路复用器监听多个文件描述符的事件，在事件发生时进行非阻塞 I/O 操作，可以有效地管理大量的并发 I/O 请求。

5.3 嵌入式系统

在嵌入式系统中，资源通常比较有限，使用非阻塞 I/O 和事件驱动模型可以在有限的资源下实现高效的 I/O 处理。例如，一个嵌入式设备需要同时与多个传感器进行数据交互，通过事件驱动模型可以在单线程内处理多个传感器的 I/O 事件，减少系统的资源消耗。

6. 总结与注意事项

非阻塞 I/O 的事件驱动是一种强大的编程模型，可以有效地提高系统的并发处理能力和资源利用率。在使用过程中，需要注意以下几点：

  • 事件处理逻辑的复杂性：随着应用程序规模的扩大，事件处理逻辑可能会变得复杂。为了保持代码的可读性和可维护性，应该将不同的事件处理逻辑封装成独立的函数或模块。
  • 内存管理：在处理大量并发 I/O 操作时，需要注意内存管理。例如，在读取数据时，要确保分配足够的内存空间，并且及时释放不再使用的内存。
  • 错误处理：在非阻塞 I/O 操作中，错误处理尤为重要。要正确处理诸如 EAGAIN、EWOULDBLOCK 等错误，以及其他可能发生的 I/O 错误。
  • 选择合适的事件多路复用器：根据应用场景的特点，选择合适的事件多路复用器。select 适用于小规模的 I/O 多路复用场景，poll 在一定程度上改进了 select 的性能，而 epoll 则适用于处理大量并发连接的高性能场景。

通过合理运用非阻塞 I/O 的事件驱动模型，可以开发出高效、可靠的 Linux 应用程序，满足各种不同的应用需求。