C语言非阻塞IO[编辑 | 编辑源代码]

概述[编辑 | 编辑源代码]

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

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

非阻塞IO vs 阻塞IO[编辑 | 编辑源代码]

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

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

设置非阻塞模式[编辑 | 编辑源代码]

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

#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;
}

输出示例[编辑 | 编辑源代码]

如果文件`example.txt`为空或不可读，程序可能会输出：

No data available now, try again later.

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

非阻塞IO的实际应用[编辑 | 编辑源代码]

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

示例：非阻塞网络服务器[编辑 | 编辑源代码]

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

#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;
}