编辑“︁C 语言非阻塞io”︁

= C语言非阻塞IO =

== 概述 ==
'''非阻塞IO'''（Non-blocking I/O）是C语言网络编程中的一种重要模式，它允许程序在等待I/O操作完成时继续执行其他任务，而不是被阻塞（即停止执行）直到操作完成。这种机制对于提高程序的效率和响应性至关重要，特别是在需要处理多个并发连接的网络应用中。

在传统的'''阻塞IO'''模式下，当程序执行一个I/O操作（如读取数据）时，它会一直等待，直到数据可用或操作完成。而在非阻塞模式下，如果数据不可用，操作会立即返回一个错误（通常是`EAGAIN`或`EWOULDBLOCK`），程序可以继续执行其他任务。

== 非阻塞IO vs 阻塞IO ==
以下是非阻塞IO与阻塞IO的主要区别：

{| class="wikitable"
|-
! 特性 !! 阻塞IO !! 非阻塞IO
|-
| 等待行为 || 阻塞直到操作完成 || 立即返回，无论操作是否完成
|-
| 程序控制权 || 交出控制权，无法执行其他任务 || 保留控制权，可以执行其他任务
|-
| 适用场景 || 简单、单线程应用 || 高性能、多任务应用
|}

== 设置非阻塞模式 ==
在C语言中，可以通过`fcntl`函数将文件描述符设置为非阻塞模式。以下是一个示例：

<syntaxhighlight lang="c">
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

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

    // 获取当前文件描述符的标志
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl F_GETFL failed");
        close(fd);
        return 1;
    }

    // 设置非阻塞标志
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL failed");
        close(fd);
        return 1;
    }

    char buffer[1024];
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
    if (bytes_read == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("No data available now, try again later.\n");
        } else {
            perror("read failed");
        }
    } else {
        printf("Read %zd bytes: %.*s\n", bytes_read, (int)bytes_read, buffer);
    }

    close(fd);
    return 0;
}
</syntaxhighlight>

=== 输出示例 ===
如果文件`example.txt`为空或不可读，程序可能会输出：
<pre>
No data available now, try again later.
</pre>

如果文件有内容，程序会读取并打印内容。

== 非阻塞IO的实际应用 ==
非阻塞IO常用于以下场景：
1. '''多路复用'''（如`select`、`poll`、`epoll`）：结合非阻塞IO，可以高效地管理多个I/O操作。
2. '''高性能服务器'''：如Web服务器需要同时处理数千个连接。
3. '''实时系统'''：需要快速响应多个事件。

=== 示例：非阻塞网络服务器 ===
以下是一个简单的非阻塞网络服务器示例，使用`select`多路复用：

<syntaxhighlight lang="c">
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#define PORT 8080
#define MAX_CLIENTS 10

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 设置非阻塞模式
    int flags = fcntl(server_fd, F_GETFL, 0);
    fcntl(server_fd, F_SETFL, flags | O_NONBLOCK);

    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    if (listen(server_fd, MAX_CLIENTS) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }

    fd_set readfds;
    int client_sockets[MAX_CLIENTS] = {0};

    while (1) {
        FD_ZERO(&readfds);
        FD_SET(server_fd, &readfds);
        int max_fd = server_fd;

        for (int i = 0; i < MAX_CLIENTS; i++) {
            if (client_sockets[i] > 0) {
                FD_SET(client_sockets[i], &readfds);
                if (client_sockets[i] > max_fd) {
                    max_fd = client_sockets[i];
                }
            }
        }

        int activity = select(max_fd + 1, &readfds, NULL, NULL, NULL);
        if (activity < 0 && errno != EINTR) {
            perror("select error");
        }

        if (FD_ISSET(server_fd, &readfds)) {
            int new_socket = accept(server_fd, NULL, NULL);
            if (new_socket < 0) {
                perror("accept error");
                continue;
            }

            // 设置非阻塞模式
            flags = fcntl(new_socket, F_GETFL, 0);
            fcntl(new_socket, F_SETFL, flags | O_NONBLOCK);

            for (int i = 0; i < MAX_CLIENTS; i++) {
                if (client_sockets[i] == 0) {
                    client_sockets[i] = new_socket;
                    printf("New connection, socket fd: %d\n", new_socket);
                    break;
                }
            }
        }

        for (int i = 0; i < MAX_CLIENTS; i++) {
            if (client_sockets[i] > 0 && FD_ISSET(client_sockets[i], &readfds)) {
                char buffer[1024] = {0};
                ssize_t bytes_read = read(client_sockets[i], buffer, sizeof(buffer));
                if (bytes_read <= 0) {
                    if (bytes_read == 0 || errno == EAGAIN || errno == EWOULDBLOCK) {
                        // 连接关闭或暂时无数据
                        close(client_sockets[i]);
                        client_sockets[i] = 0;
                    } else {
                        perror("read error");
                    }
                } else {
                    printf("Received: %s\n", buffer);
                    write(client_sockets[i], buffer, bytes_read);
                }
            }
        }
    }

    return 0;
}
</syntaxhighlight>

=== 服务器行为 ===
1. 服务器监听端口`8080`。
2. 当有新连接时，接受并设置为非阻塞模式。
3. 使用`select`监控所有活跃的连接。
4. 如果某个客户端发送数据，服务器会读取并回显。

== 非阻塞IO的优缺点 ==
=== 优点 ===
* '''高效'''：程序无需等待I/O完成，可以处理其他任务。
* '''可扩展'''：适合高并发场景。
* '''实时性'''：快速响应多个事件。

=== 缺点 ===
* '''复杂性'''：需要额外的逻辑处理`EAGAIN`/`EWOULDBLOCK`。
* '''轮询开销'''：可能需要循环检查数据是否可用。

== 总结 ==
非阻塞IO是C语言网络编程中的重要技术，适用于需要高性能和并发处理的场景。通过结合多路复用（如`select`、`poll`、`epoll`），可以构建高效的网络服务器。尽管实现比阻塞IO复杂，但其优势在高负载环境下非常明显。

[[Category:编程语言]]
[[Category:C]]
[[Category:C 语言网络编程]]