#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];

    // 創(chuàng)建一個(gè)TCP套接字
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("套接字創(chuàng)建失敗");
        return -1;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    // 綁定套接字
    if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("綁定失敗");
        close(sockfd);
        return -1;
    }

    // 監(jiān)聽端口
    if (listen(sockfd, 3) < 0) {
        perror("監(jiān)聽失敗");
        close(sockfd);
        return -1;
    }

    printf("等待客戶端連接...\n");

    int new_sock;
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);

    // 接受客戶端連接
    if ((new_sock = accept(sockfd, (struct sockaddr*)&client_addr, &client_len)) < 0) {
        perror("接受連接失敗");
        close(sockfd);
        return -1;
    }

    printf("客戶端已連接。等待數(shù)據(jù)...\n");

    // 阻塞式recv：等待客戶端發(fā)送數(shù)據(jù)
    while (1) {
        printf("發(fā)起 I/O 請求：調(diào)用 recv() 等待數(shù)據(jù)...\n");
        ssize_t bytes_received = recv(new_sock, buffer, BUFFER_SIZE - 1, 0); // BUFFER_SIZE -1 保證留出 '\0'

        if (bytes_received < 0) {
            perror("recv 失敗");
            break;
        }

        if (bytes_received == 0) {
            printf("客戶端已斷開連接。\n");
            break;
        }

        buffer[bytes_received] = '\0';  // 確保字符串結(jié)束
        printf("收到數(shù)據(jù)：%s\n", buffer); // 數(shù)據(jù)到達(dá)并喚醒進(jìn)程
    }

    close(new_sock);
    close(sockfd);
    return 0;
}

ssize_t bytes_received = recv(sockfd, buffer, BUFFER_SIZE, 0);

#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );

?
#include <fcntl.h> // 包含 fcntl 相關(guān)的頭文件
#include <unistd.h> // 包含 close 和 open 函數(shù)的頭文件
#include <iostream> // 包含輸入輸出流的頭文件

int main() {
    int old_fd = open("example.txt", O_RDONLY); // 打開文件用于只讀
    if (old_fd == -1) {
        std::perror("打開文件失?。?); // 輸出錯(cuò)誤信息
        return -1;
    }

    int new_fd = fcntl(old_fd, F_DUPFD, 3); // 復(fù)制文件描述符，要求新的描述符至少為 3
    if (new_fd == -1) {
        std::perror("復(fù)制文件描述符失敗：");
        close(old_fd);
        return -1;
    }

    std::cout << "新的文件描述符：" << new_fd << std::endl; // 輸出新的文件描述符

    close(old_fd); // 關(guān)閉舊的文件描述符
    close(new_fd); // 關(guān)閉新的文件描述符

    return 0;
}

?

?
#include <fcntl.h> // 包含 fcntl 相關(guān)的頭文件
#include <unistd.h> // 包含 close 和 open 函數(shù)的頭文件
#include <iostream> // 包含輸入輸出流的頭文件

int main() {
    int fd = open("example.txt", O_RDONLY); // 打開文件用于只讀
    if (fd == -1) {
        std::perror("打開文件失?。?); // 輸出錯(cuò)誤信息
        return -1;
    }

    int flags = fcntl(fd, F_GETFD); // 獲取文件描述符的標(biāo)志
    if (flags == -1) {
        std::perror("獲取文件描述符標(biāo)志失?。?);
        close(fd);
        return -1;
    }

    // 設(shè)置 FD_CLOEXEC 標(biāo)志，使文件描述符在執(zhí)行 exec 時(shí)關(guān)閉
    if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
        std::perror("獲取文件描述符標(biāo)志失敗：");
        close(fd);
        return -1;
    }

    std::cout << "設(shè)置 FD_CLOEXEC 前的標(biāo)志：" << flags << std::endl; // 輸出設(shè)置前的標(biāo)志
    std::cout << "設(shè)置 FD_CLOEXEC 后的標(biāo)志：" << new_flags << std::endl; // 輸出設(shè)置后的標(biāo)志

    close(fd); // 關(guān)閉文件描述符
    return 0;
}

?

?
#include <fcntl.h> // 包含 fcntl 相關(guān)的頭文件
#include <unistd.h> // 包含 close 和 open 函數(shù)的頭文件
#include <iostream> // 包含輸入輸出流的頭文件

int main() {
    int fd = open("example.txt", O_RDONLY); // 打開文件用于只讀
    if (fd == -1) {
        std::perror("打開文件失敗："); // 輸出錯(cuò)誤信息
        return -1;
    }

    int flags = fcntl(fd, F_GETFL); // 獲取文件狀態(tài)標(biāo)志
    if (flags == -1) {
        std::perror("獲取文件狀態(tài)標(biāo)志失?。?);
        close(fd);
        return -1;
    }

    // 設(shè)置 O_NONBLOCK 標(biāo)志，使文件描述符處于非阻塞模式
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

    int new_flags = fcntl(fd, F_GETFL); // 再次獲取文件狀態(tài)標(biāo)志
    if (new_flags == -1) {
        std::perror("獲取文件狀態(tài)標(biāo)志失?。?);
        close(fd);
        return -1;
    }

    std::cout << "設(shè)置 O_NONBLOCK 前的標(biāo)志：" << flags << std::endl; // 輸出設(shè)置前的標(biāo)志
    std::cout << "設(shè)置 O_NONBLOCK 后的標(biāo)志：" << new_flags << std::endl; // 輸出設(shè)置后的標(biāo)志

    close(fd); // 關(guān)閉文件描述符

    return 0;
}

?

#include <iostream>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <cstring>

using namespace std;
#define PORT 8080
#define BUFFER_SIZE 1024

// 設(shè)置套接字為非阻塞模式
int setNonBlocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags == -1) {
        cerr << "獲取文件狀態(tài)標(biāo)志失敗: " << strerror(errno) << endl;
        return -1;
    }
    if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
        cerr << "設(shè)置非阻塞模式失敗: " << strerror(errno) << endl;
        return -1;
    }
    return 0;
}

int main() {
    // 創(chuàng)建套接字
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        cerr << "創(chuàng)建套接字失敗: " << strerror(errno) << endl;
        return -1;
    }

    // 設(shè)置套接字為非阻塞
    if (setNonBlocking(server_fd) == -1) {
        close(server_fd);
        return -1;
    }

    // 綁定地址和端口
    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) {
        cerr << "綁定地址和端口失敗: " << strerror(errno) << endl;
        close(server_fd);
        return -1;
    }

    // 監(jiān)聽連接
    if (listen(server_fd, 3) < 0) {
        cerr << "監(jiān)聽連接失敗: " << strerror(errno) << endl;
        close(server_fd);
        return -1;
    }

    cout << "服務(wù)器正在監(jiān)聽端口 " << PORT << endl;

    // 接受客戶端連接
    struct sockaddr_in client_address;
    socklen_t addr_len = sizeof(client_address);
    int client_fd = -1;

    while (client_fd == -1) {
        client_fd = accept(server_fd, (struct sockaddr *)&client_address, &addr_len);

        if (client_fd == -1) {
            // 如果沒有連接，errno 會(huì)被設(shè)置為 EWOULDBLOCK 或 EAGAIN
            if (errno == EWOULDBLOCK || errno == EAGAIN) {
                cout << "沒有可用連接，繼續(xù)等待..." << endl;
                sleep(1);  // 延時(shí) 1s 后重試
            } else {
                cerr << "接受客戶端連接失敗: " << strerror(errno) << endl;
                close(server_fd);
                return -1;
            }
        }
    }

    cout << "接受到客戶端連接" << endl;

    // 設(shè)置客戶端套接字為非阻塞
    if (setNonBlocking(client_fd) == -1) {
        close(server_fd);
        close(client_fd);
        return -1;
    }

    char buffer[BUFFER_SIZE];
    int bytes_read;

    while (true) {
        // 嘗試讀取客戶端數(shù)據(jù)
        bytes_read = recv(client_fd, buffer, sizeof(buffer), 0);

        if (bytes_read == -1) {
            // 如果沒有數(shù)據(jù)，errno 會(huì)被設(shè)置為 EWOULDBLOCK 或 EAGAIN
            if (errno == EWOULDBLOCK || errno == EAGAIN) {
                cout << "沒有可用數(shù)據(jù)，執(zhí)行其他任務(wù)..." << endl;
                usleep(100000);  // 假設(shè)其他任務(wù)的延時(shí)（100ms）
            } else {
                cerr << "接收數(shù)據(jù)失敗: " << strerror(errno) << endl;
                break;
            }
        } else if (bytes_read == 0) {
            // 客戶端關(guān)閉連接
            cout << "客戶端已斷開連接" << endl;
            break;
        } else {
            // 成功接收到數(shù)據(jù)
            buffer[bytes_read] = '\0';  // 確保接收到的字符串以 '\0' 結(jié)尾
            cout << "收到數(shù)據(jù): " << buffer << endl;
        }
    }

    // 關(guān)閉連接
    close(client_fd);
    close(server_fd);

    return 0;
}

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

struct timeval
{
__time_t tv_sec;		/* 秒.  */
__suseconds_t tv_usec;	/* 微秒.  */
};

#include <sys/select.h>
void FD_ZERO(fd_set *set);			/* 將fdset所指向的集合初始化為空 */
void FD_SET(int fd, fd_set *set);	/* 將文件描述符fd添加到由fdset所指向的集合中 */
void FD_CLR(int fd, fd_set *set);	/* 將文件描述符fd從fdset所指向的集合中移除 */
int FD_ISSET(int fd, fd_set *set);	/* 檢查已連接的套接字是否有數(shù)據(jù)可讀 */

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>
#include <fcntl.h>
#include <sys/select.h>

#define SERVER_PORT 8080
#define MAX_CLIENTS 10
#define BUF_SIZE 1024

void set_socket_non_blocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
    int server_fd, client_fd, max_fd, new_socket;
    struct sockaddr_in server_addr;
    char buffer[BUF_SIZE];
    fd_set read_fds, master_fds;
    struct timeval timeout;

    // 創(chuàng)建 TCP socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("創(chuàng)建套接字失敗");
        return -1;
    }

    // 設(shè)置服務(wù)器地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(SERVER_PORT);

    // 綁定套接字
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("綁定失敗");
        return -1;
    }

    // 開始監(jiān)聽客戶端連接
    if (listen(server_fd, MAX_CLIENTS) == -1) {
        perror("監(jiān)聽失敗");
        return -1;
    }

    // 設(shè)置 server_fd 為非阻塞
    set_socket_non_blocking(server_fd);

    // 初始化 fd_set
    FD_ZERO(&master_fds);
    FD_SET(server_fd, &master_fds);
    max_fd = server_fd;

    while (true) {
        // 將 master_fds 賦值給 read_fds，因?yàn)?select() 會(huì)修改 read_fds
        read_fds = master_fds;

        // 設(shè)置超時(shí)，阻塞 5 秒
        timeout.tv_sec = 5;
        timeout.tv_usec = 0;

        // 調(diào)用 select() 進(jìn)行 I/O 多路復(fù)用
        int activity = select(max_fd + 1, &read_fds, nullptr, nullptr, &timeout);
        if (activity == -1) {
            perror("select 錯(cuò)誤");
            break;
        } else if (activity == 0) {
            std::cout << "沒有活動(dòng)，繼續(xù)等待...\n";
            continue;
        }

        // 遍歷所有文件描述符
        for (int fd = 0; fd <= max_fd; ++fd) {
            // 如果 fd 是活動(dòng)的文件描述符
            if (FD_ISSET(fd, &read_fds)) {
                if (fd == server_fd) {
                    // 處理新的客戶端連接
                    if ((new_socket = accept(server_fd, nullptr, nullptr)) == -1) {
                        perror("接受連接失敗，繼續(xù)...");
                        continue;
                    }

                    std::cout << "新連接，套接字 fd: " << new_socket << "\n";

                    // 設(shè)置新的套接字為非阻塞
                    set_socket_non_blocking(new_socket);

                    // 將新的客戶端套接字加入 fd_set
                    FD_SET(new_socket, &master_fds);
                    if (new_socket > max_fd) {
                        max_fd = new_socket;
                    }
                } else {
                    // 處理已連接客戶端的 I/O 操作
                    int bytes_read = read(fd, buffer, sizeof(buffer) - 1);
                    if (bytes_read == 0) {
                        // 客戶端關(guān)閉連接
                        std::cout << "客戶端斷開連接，套接字 fd: " << fd << "\n";
                        close(fd);
                        FD_CLR(fd, &master_fds);
                    } else if (bytes_read > 0) {
                        // 處理收到的數(shù)據(jù)
                        buffer[bytes_read] = '\0';
                        std::cout << "收到來自客戶端 " << fd << " 的數(shù)據(jù): " << buffer << "\n";

                        // 回送數(shù)據(jù)給客戶端
                        send(fd, buffer, bytes_read, 0);
                    } else {
                        perror("讀取錯(cuò)誤");
                        close(fd);
                        FD_CLR(fd, &master_fds);
                    }
                }
            }
        }
    }

    close(server_fd);
    return 0;
}

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {
    int   fd;         // 要監(jiān)視的文件描述符
    short events;     // 監(jiān)視的事件
    short revents;    // 實(shí)際發(fā)生的事件
};

#include <iostream>
#include <vector>
#include <poll.h>
#include <unistd.h>
#include <cstring>
#include <arpa/inet.h>
#include <fcntl.h>

#define PORT 8080
#define MAX_EVENTS 1024
#define BUFFER_SIZE 1024

int set_non_blocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1)
        return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    
    // 創(chuàng)建監(jiān)聽套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // 設(shè)置套接字選項(xiàng)
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        perror("setsockopt");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    // 設(shè)置地址結(jié)構(gòu)
    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");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    // 開始監(jiān)聽
    if (listen(server_fd, 10) < 0) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    // 設(shè)置服務(wù)器套接字為非阻塞
    if (set_non_blocking(server_fd) < 0) {
        perror("set_non_blocking");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    
    // 初始化pollfd數(shù)組
    std::vector<struct pollfd> fds;
    struct pollfd server_pollfd;
    server_pollfd.fd = server_fd;
    server_pollfd.events = POLLIN;
    server_pollfd.revents = 0;
    fds.push_back(server_pollfd);
    
    std::cout << "服務(wù)器正在端口 " << PORT << " 上監(jiān)聽" << std::endl;
    
    while (true) {
        int activity = poll(fds.data(), fds.size(), -1);
        
        if (activity < 0) {
            perror("poll error");
            break;
        }
        
        for (size_t i = 0; i < fds.size(); ++i) {
            // 檢測是否有事件發(fā)生
            if (fds[i].revents & POLLIN) {
                if (fds[i].fd == server_fd) {
                    // 有新的連接請求
                    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
                        perror("accept");
                        continue;
                    }
                    
                    // 設(shè)置新套接字為非阻塞
                    if (set_non_blocking(new_socket) < 0) {
                        perror("set_non_blocking");
                        close(new_socket);
                        continue;
                    }
                    
                    // 添加新套接字到pollfd數(shù)組
                    struct pollfd client_pollfd;
                    client_pollfd.fd = new_socket;
                    client_pollfd.events = POLLIN;
                    client_pollfd.revents = 0;
                    fds.push_back(client_pollfd);
                    
                    std::cout << "新連接，socket fd: " << new_socket << std::endl;
                } else {
                    // 處理已連接的客戶端數(shù)據(jù)
                    char buffer[BUFFER_SIZE];
                    int valread = read(fds[i].fd, buffer, BUFFER_SIZE);
                    
                    if (valread <= 0) {
                        // 客戶端關(guān)閉連接或發(fā)生錯(cuò)誤
                        close(fds[i].fd);
                        std::cout << "連接關(guān)閉，socket fd: " << fds[i].fd << std::endl;
                        fds.erase(fds.begin() + i);
                        --i;
                        continue;
                    }
                    
                    buffer[valread] = '\0';
                    std::cout << "收到: " << buffer << " 來自socket fd: " << fds[i].fd << std::endl;
                    
                    // 回顯數(shù)據(jù)給客戶端
                    send(fds[i].fd, buffer, valread, 0);
                }
            }
        }
    }
    
    // 關(guān)閉所有套接字
    for (auto &pfd : fds) {
        close(pfd.fd);
    }
    
    return 0;
}

#include <sys/epoll.h>
int epoll_create1(int flags);

#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

struct epoll_event {
    uint32_t events;    /* Epoll events */
    epoll_data_t data;  /* User data variable */
};

typedef union epoll_data {
    void *ptr;
    int fd;
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

struct epoll_event event;
event.events = EPOLLIN | EPOLLET; 	// 監(jiān)聽可讀事件，采用邊緣觸發(fā)
event.data.fd = sock_fd;			// 將sock_fd綁定到event.data.fd
// 使用EPOLL_CTL_ADD操作將sock_fd加入epoll實(shí)例
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock_fd, &event) == -1) {
    perror("epoll_ctl: add");
    exit(EXIT_FAILURE);
}

#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

struct epoll_event events[MAX_EVENTS];
int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
if (n == -1) {
    perror("epoll_wait");
    exit(EXIT_FAILURE);
}
for (int i = 0; i < n; i++) {
    if (events[i].events & EPOLLIN) {
        // 處理可讀事件
    }
    // 處理其他事件類型
}

close(epoll_fd);

int flags = fcntl(sock_fd, F_GETFL, 0);
fcntl(sock_fd, F_SETFL, flags | O_NONBLOCK);

ssize_t bytes_read;
while ((bytes_read = read(sock_fd, buffer, sizeof(buffer))) > 0) {
    // 處理數(shù)據(jù)
}
if (bytes_read < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
    perror("read failed");
    // 錯(cuò)誤處理
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAX_EVENTS 10
#define PORT 8080
#define BUFFER_SIZE 1024

// 設(shè)置文件描述符為非阻塞
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl(F_GETFL)");
        return -1;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl(F_SETFL)");
        return -1;
    }
    return 0;
}

// 處理客戶端數(shù)據(jù)的函數(shù)
void handle_client_data(int client_fd) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(client_fd, buffer, sizeof(buffer));
    if (bytes_read == -1) {
        if (errno != EAGAIN && errno != EWOULDBLOCK) {
            perror("read failed");
            close(client_fd);
        }
    } else if (bytes_read == 0) {
        // 客戶端關(guān)閉連接
        printf("Client disconnected\n");
        close(client_fd);
    } else {
        // 處理讀取的數(shù)據(jù)
        buffer[bytes_read] = '\0';
        printf("Received data: %s\n", buffer);

        // 發(fā)送數(shù)據(jù)到客戶端
        ssize_t bytes_written = write(client_fd, buffer, bytes_read);
        if (bytes_written == -1) {
            perror("write failed");
            close(client_fd);
        }
    }
}

int main() {
    int server_fd, epoll_fd;
    struct sockaddr_in server_addr;
    struct epoll_event ev, events[MAX_EVENTS];

    // 創(chuàng)建監(jiān)聽套接字
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 設(shè)置服務(wù)器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 綁定套接字
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 監(jiān)聽連接
    if (listen(server_fd, 10) == -1) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 創(chuàng)建 epoll 實(shí)例
    epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1 failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 將服務(wù)器套接字加入 epoll 事件監(jiān)聽
    ev.events = EPOLLIN | EPOLLET;  // 監(jiān)聽可讀事件，采用邊緣觸發(fā)模式
    ev.data.fd = server_fd;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) == -1) {
        perror("epoll_ctl failed");
        close(server_fd);
        close(epoll_fd);
        exit(EXIT_FAILURE);
    }

    // 主事件循環(huán)
    while (1) {
        int num_events = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (num_events == -1) {
            perror("epoll_wait failed");
            break;
        }

        // 處理就緒事件
        for (int i = 0; i < num_events; i++) {
            if (events[i].data.fd == server_fd) {
                // 服務(wù)器套接字有連接請求
                int client_fd = accept(server_fd, NULL, NULL);
                if (client_fd == -1) {
                    perror("accept failed");
                    continue;
                }

                // 設(shè)置客戶端套接字為非阻塞
                if (set_nonblocking(client_fd) == -1) {
                    close(client_fd);
                    continue;
                }

                // 將客戶端套接字添加到 epoll 中
                ev.events = EPOLLIN | EPOLLET;  // 監(jiān)聽客戶端的可讀事件，采用邊緣觸發(fā)模式
                ev.data.fd = client_fd;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev) == -1) {
                    perror("epoll_ctl: add client failed");
                    close(client_fd);
                    continue;
                }

                printf("New client connected\n");

            } else if (events[i].events & EPOLLIN) {
                // 客戶端有數(shù)據(jù)可讀
                handle_client_data(events[i].data.fd);
            }
        }
    }

    // 清理資源
    close(server_fd);
    close(epoll_fd);
    return 0;
}

fcntl(fd, F_SETOWN , pid);

flags = fcntl(fd, F_GETFL);  // get current flags
fcntl(fd, F_SETFL, flags | O_ASYNC | O_NONBLOCK);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>

#define PORT 8080
#define MAXLINE 1024

static int sockfd;  // 監(jiān)聽套接字
static struct sockaddr_in cli_addr;
static socklen_t clilen = sizeof(cli_addr);

// 信號處理函數(shù)
void do_sometime(int signal) {
    char buffer[MAXLINE] = {0};
    int len = recvfrom(sockfd, buffer, MAXLINE, 0, (struct sockaddr *)&cli_addr, (socklen_t*)&clilen);
    if (len > 0) {
        printf("收到客戶端消息: %s\n", buffer);
        strcat(buffer, "→[Msg]");
        sendto(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&cli_addr, clilen);  // 回顯消息
    } else {
        printf("沒有收到數(shù)據(jù)或出現(xiàn)錯(cuò)誤\n");
    }
}

int main(int argc, char const *argv[]) {
    // 創(chuàng)建套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
    
    // 注冊信號處理函數(shù)
    struct sigaction act;
    act.sa_handler = do_sometime;
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_RESTART;  // 重新啟動(dòng)被信號中斷的系統(tǒng)調(diào)用
    sigaction(SIGIO, &act, NULL);

    // 創(chuàng)建并初始化地址結(jié)構(gòu)
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = INADDR_ANY;
    
    // 設(shè)置文件描述符的擁有者為當(dāng)前進(jìn)程
    fcntl(sockfd, F_SETOWN, getpid());
    int flags = fcntl(sockfd, F_GETFL, 0);
    // 啟用信號驅(qū)動(dòng)模式 | 設(shè)置文件描述符為非阻塞模式
    fcntl(sockfd, F_SETFL, flags | O_ASYNC | O_NONBLOCK);
    
    // 綁定地址
    if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("bind failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    while (1)
        sleep(1);   // 等待信號

    close(sockfd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <aio.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <errno.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    // 創(chuàng)建 TCP 套接字
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);

    // 設(shè)置服務(wù)器地址結(jié)構(gòu)
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 綁定地址
    bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));

    // 監(jiān)聽連接
    listen(server_fd, 5);

    printf("Server listening on port %d...\n", PORT);

    // 接受客戶端連接
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);

    // 設(shè)置異步讀操作
    char buffer[BUFFER_SIZE];
    struct aiocb aio_read_cb;
    memset(&aio_read_cb, 0, sizeof(struct aiocb));
    aio_read_cb.aio_fildes = client_fd;
    aio_read_cb.aio_buf = buffer;
    aio_read_cb.aio_nbytes = sizeof(buffer);
    aio_read_cb.aio_offset = 0;

    // 發(fā)起異步讀操作
    aio_read(&aio_read_cb);

    // 等待讀操作完成
    while (aio_error(&aio_read_cb) == EINPROGRESS) {
        // 可以執(zhí)行其他操作
        usleep(10000);  // 等待10ms
    }

    // 讀取完成，獲取結(jié)果
    int bytes_read = aio_return(&aio_read_cb);

    printf("Received message: %s\n", buffer);

    // 發(fā)送數(shù)據(jù)到客戶端
    send(client_fd, buffer, bytes_read, 0);

    close(client_fd);
    close(server_fd);
    return 0;
}