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/n/316757.html