epoll使用詳解

一、epoll使用ET

在使用epoll的時候我們需要注意兩種工作方式，一種是LT（Level Trigger）方式，一種是ET（Edge Trigger）方式。ET方式的精度比LT方式高，適用於需要高並發的場景。在使用ET方式時，我們需要使用非阻塞IO，因為只有在返回EAGAIN或EWOULDBLOCK錯誤後才能保證一定要讀或寫完所有的數據。如下是使用ET模式的示例代碼：

int epoll_fd = epoll_create1(0);
if (epoll_fd < 0) {
    perror("epoll_create1 error");
    exit(EXIT_FAILURE);
}

struct epoll_event event;
event.events = EPOLLIN|EPOLLET;
event.data.fd = sockfd;
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &event) < 0) {
    perror("epoll_ctl error");
    exit(EXIT_FAILURE);
}

while(1) {
    struct epoll_event events[MAX_EVENTS];
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    if(nfds == -1) {
        perror("epoll_wait error");
        exit(EXIT_FAILURE);
    }

    for(int i = 0; i < nfds; i++) {
        if(events[i].events & EPOLLIN) {
            // 讀取事件
        } else if (events[i].events & EPOLLOUT) {
            // 寫入事件
        } else if (events[i].events & (EPOLLERR | EPOLLHUP)) {
            // 出錯事件
            close(events[i].data.fd);
        }
    }
}

二、epoll使用et套介面

ET方式下我們還可以使用邊沿觸發的套接字（et套介面），與普通套接字相比可以更好地處理並發問題。下面是et套接字的示例代碼：

int listenfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(listenfd, F_SETFL, fcntl(listenfd, F_GETFL, 0) | O_NONBLOCK);

struct epoll_event ev, events[MAX_EVENTS];
ev.events = EPOLLIN|EPOLLET;
ev.data.fd = listenfd;
int epollfd = epoll_create1(0);
epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &ev);

while (1) {
    int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
    for(int i = 0; i < nfds; i++) {
        if(events[i].data.fd == listenfd) {  // 邊沿觸發
            while(1) {
                int connfd = accept(listenfd, (struct sockaddr*)&clientaddr, &clientlen);
                if(connfd < 0) {
                    if(errno == EAGAIN || errno == EWOULDBLOCK) break;
                    else perror("accept error");
                } else {
                    fcntl(connfd, F_SETFL, fcntl(connfd, F_GETFL, 0) | O_NONBLOCK);
                    ev.events = EPOLLIN|EPOLLET;
                    ev.data.fd = connfd;
                    epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &ev);
                }
            }
        } else {
            // 處理其它ET事件
        }
    }
}

三、epoll使用udp

在使用UDP時，我們需要使用epoll的EPOLLIN事件來監聽讀事件，和TCP的讀取方式不同，UDP使用recvfrom函數來讀取數據。

int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);

if(bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
    perror("bind error");
    exit(EXIT_FAILURE);
}

int epollfd = epoll_create1(0);
if (epollfd == -1) {
    perror("epoll_create1 error");
    exit(EXIT_FAILURE);
}

struct epoll_event event;
event.data.fd = sockfd;
event.events = EPOLLIN;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &event) == -1) {
    perror("epoll_ctl error");
    exit(EXIT_FAILURE);
}

while (1) {
    struct epoll_event events[MAX_EVENTS];
    int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
    for(int i = 0; i < nfds; i++) {
        if(events[i].data.fd == sockfd) {
            struct sockaddr_in clientaddr;
            socklen_t clientaddrlen = sizeof(clientaddr);
            char buffer[MAXLINE];
            int n = recvfrom(sockfd, buffer, MAXLINE, 0, (struct sockaddr *)&clientaddr, &clientaddrlen);
            buffer[n] = '\0';
            printf("recvfrom:%s\n", buffer);
        }
    }
}

四、epoll使用共享內存

在多進程的服務中，我們可以使用共享內存來實現進程間的通信。在監聽socket上使用epoll事件，接受到新的連接後，把socket的信息寫入共享內存，讓其它進程讀取。

#include 

int shmid = shmget(IPC_PRIVATE, sizeof(int), 0644|IPC_CREAT);
if(shmid == -1) {
    perror("shmget error");
    exit(EXIT_FAILURE);
}

int serverfd = socket(AF_INET, SOCK_STREAM, 0);
// 綁定等操作

if(fork() == 0) {
    // 子進程
    while(1) {
        int *p = (int*)shmat(shmid, 0, SHM_RDONLY);
        printf("listenfd=%d", *p);
        shmdt(p);
    }
} else {
    // 父進程
    listen(serverfd, SOMAXCONN);
    struct epoll_event ev, events[MAX_EVENTS];
    int epollfd = epoll_create1(0);
    ev.events = EPOLLIN|EPOLLET;
    ev.data.fd = serverfd;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, serverfd, &ev);

    while (1) {
        int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
        for(int i = 0; i < nfds; i++) {
            if(events[i].data.fd == serverfd) {
                int connfd = accept(serverfd, (struct sockaddr*)&cliaddr, &addrlen);
                if(connfd < 0) {
                    if(errno == EAGAIN || errno == EWOULDBLOCK) break; // 內核緩衝區沒有數據
                    else perror("accept error");
                } else {
                    fcntl(connfd, F_SETFL, fcntl(connfd, F_GETFL, 0) | O_NONBLOCK);
                    int *p = (int*)shmat(shmid, NULL, 0);
                    *p = connfd;
                    shmdt(p);
                }
            }
        }
    }
}

五、epoll使用舉例

下面我們來看一個使用epoll的例子，代碼實現了一個簡單的HTTP伺服器：

int listenfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(listenfd, F_SETFL, fcntl(listenfd, F_GETFL, 0) | O_NONBLOCK);

struct sockaddr_in serveraddr;
memset(&serveraddr, 0, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(port);

bind(listenfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
listen(listenfd, SOMAXCONN);

int epfd = epoll_create(EPOLLSIZE);
struct epoll_event event, events[MAXEPOLLSIZE];
event.events = EPOLLIN | EPOLLET;
event.data.fd = listenfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &event);

while (1) {
    int n = epoll_wait(epfd, events, MAXEPOLLSIZE, -1);
    for (int i = 0; i < n; ++i) {
        if (events[i].data.fd == listenfd) {
            struct sockaddr_in clientaddr;
            socklen_t addrlen = sizeof(clientaddr);
            int connfd = accept(listenfd, (struct sockaddr *)&clientaddr, &addrlen);
            fcntl(connfd, F_SETFL, fcntl(connfd, F_GETFL, 0) | O_NONBLOCK);
            event.data.fd = connfd;
            event.events = EPOLLIN | EPOLLET;
            epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &event);
        } else if (events[i].events & EPOLLIN) {
            char buf[BUFSIZE];
            int connfd = events[i].data.fd;
            int n = read(connfd, buf, BUFSIZE);
            if (n <= 0) {
                close(connfd);
                epoll_ctl(epfd, EPOLL_CTL_DEL, connfd, &events[i]);
                continue;
            }
            // 處理HTTP請求

            char header[HEADERLEN];
            resp_header(header, 200, strlen(resp), "text/plain");
            write(connfd, header, strlen(header));
            write(connfd, resp, strlen(resp));
            close(connfd);
            epoll_ctl(epfd, EPOLL_CTL_DEL, connfd, &events[i]);
        }
    }
}

六、epoll使用回調通知嗎

epoll基於事件驅動的方式，使用回調函數來處理事件。下面是一個簡單的回調函數示例代碼：

void handle_event(int epoll_fd, int fd, int event_type) {
    // 處理事件
} 

int epoll_fd = epoll_create1(0);
if(epoll_fd < 0) {
    perror("epoll create");
    exit(EXIT_FAILURE);
}

struct epoll_event event;
event.data.fd = sockfd;
event.events = EPOLLIN | EPOLLET;
event.data.ptr = &handle_event; // 使用回調函數
if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &event) < 0) {
    perror("epoll ctl");
    close(sockfd);
    exit(EXIT_FAILURE);
}

while(1) {
    struct epoll_event events[MAX_EVENTS];
    int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    for(int i = 0; i < nfds; i++) {
        int fd = events[i].data.fd;
        int event_type = events[i].events;
        void (*cb)(int, int, int) = events[i].data.ptr;
        (*cb)(epoll_fd, fd, event_type);
    }
}

七、epoll原理

epoll利用了Linux內核提供的I/O事件通知機制，通過註冊文件描述符將其與特定事件聯繫起來，當註冊的事件發生時，內核會幫助我們進行觸發，通知用戶程序進行操作。其機制與信號機制類似，但比信號更加高效。下面是一個簡單的epoll原理圖：

八、epoll函數

epoll的函數包括epoll_create, epoll_ctl, epoll_wait。其中epoll_create函數用於創建一個epoll的文件描述符，epoll_ctl函數用於添加、刪除或修改某個文件描述符的事件，epoll_wait函數用於等待事件的發生。

九、epoll實現原理

epoll的實現原理可以歸納為以下幾個步驟：

1、創建一個epoll的文件描述符。

2、使用epoll_ctl函數註冊文件描述符和對應的事件。

3、內核註冊文件描述符上的事件，將其加入到一個紅黑樹中，根據需要創建等待隊列。

4、使用epoll_wait函數等待事件的發生，如果有事件發生，內核會通知用戶程序。

5、用戶程序根據事件類型，進行相應的處理。

原創文章，作者：WFXCJ，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/316757.html