Question

当EPOLLONESHOT指定时，水平触发和边缘触发模式之间有什么区别？

已经有一个类似的问题here。 “卧虎藏龙”的回答似乎并不正确（据我所知，其他答案并未回答我的问题）。

我尝试了以下内容：

服务器向客户端发送2个字节，而客户端在epoll_wait
客户端从epoll_wait返回，然后读取1个字节。
客户重新召开活动（因为EPOLLONESHOT）
客户再次致电epoll_wait。在这里，对于这两种情况（LT＆amp; ET），epoll_wait不等待，但立即返回（与“蹲伏小猫”的答案相反）
客户端可以读取第二个字节

LT＆amp; amp; ET，当EPOLLONESHOT指定时？

Answer 1

我认为底线答案是＆＃34;没有差异＆＃34;。

查看php documentation，似乎fd会在被一次性禁用之前记住最后设置的位。它记得它是一次性的，它记得它是否是ET。

这是徒劳的，因为fd在被修改之前被禁用，下一次调用EPOLL_CTL_MOD将清除所有这些，并替换为新MOD所说的任何内容。

话虽如此，我不明白为什么有人会同时想要EPOLLET和EPOLLONESHOT。对我来说，EPOLLET的全部意义在于，在某些编程模型（即微线程）之下，它完全遵循语义。这意味着我可以在开始时将fd添加到epoll，然后再也不必执行另一个与epoll相关的系统调用。

另一方面，

EPOLLONESHOT被那些想要对fd何时被观看以及何时不能进行非常严格控制的人使用。根据定义，这与EPOLLET的用法相反。我不认为这两者在概念上是兼容的。

Answer 2

另一位发帖人说“我不明白为什么有人会同时想要 EPOLLET 和 EPOLLONESHOT。”实际上，根据 epoll(7)，有一个用例：

<块引用>

由于即使使用边缘触发的 epoll，在接收到多个数据块时也可以生成多个事件，因此调用者可以选择指定 EPOLLONESHOT 标志，以告诉 epoll在收到带有 epoll_wait(2) 的事件后禁用关联的文件描述符。

Answer 3

关键是EPOLL会不会对待EPOLLET的组合| EPOLLONESHOT 和 EPOLLLT | EPOLLONESHOT 作为特例。据我所知，事实并非如此。 EPOLL 只是分别关心它们。对于 EPOLLET 和 EPOLLLT，区别仅在于函数 ep_send_events，如果设置了 EPOLLET，则函数会调用 list_add_tail 将 epitem 添加到 {{1} 中的就绪列表中}} 目的。对于epoll_fd/eventepoll，作用是禁用EPOLLONESHOT。所以我认为它们之间的不同在于fd和ET之间的不同。您可以使用我认为的以下代码检查结果

LT

客户是

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

#define MAX_EVENT_NUMBER 1024

int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd, bool oneshot)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    if(oneshot)
        event.events |= EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}
// reset the fd with EPOLLONESHOT
void reset_oneshot(int epollfd, int fd)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}

int main(int argc, char** argv)
{
    if(argc <= 2)
    {
        printf("usage: %s ip_address port_number\n", basename(argv[0]));
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(PF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);
    ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
    assert(ret != -1);

    ret = listen(listenfd, 5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    addfd(epollfd, listenfd, false);
    while(1)
    {
        printf("next loop: -----------------------------");
        int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(ret < 0)
        {
            printf("epoll failure\n");
            break;
        }
        for(int i = 0; i < ret; i++)
        {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd)
            {
                printf("into listenfd part\n");
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr*)&client_address,
                     &client_addrlength);
                printf("receive connfd: %d\n", connfd);
                addfd(epollfd, connfd, true);
                // reset_oneshot(epollfd, listenfd);
            }
            else if(events[i].events & EPOLLIN)
            {
                printf("into linkedfd part\n");
                printf("start new thread to receive data on fd: %d\n", sockfd);
                char buf[2];
                memset(buf, '\0', 2);
                // just read one byte, and reset the fd with EPOLLONESHOT, check whether still EPOLLIN event
                int ret = recv(sockfd, buf, 2 - 1, 0);

                if(ret == 0)
                {
                    close(sockfd);
                    printf("foreigner closed the connection\n");
                    break;
                }
                else if(ret < 0)
                {
                    if(errno == EAGAIN)
                    {
                        printf("wait to the client send the new data, check the oneshot memchnism\n");
                        sleep(10);
                        reset_oneshot(epollfd, sockfd);
                        printf("read later\n");
                        break;
                    }
                }
                else {
                    printf("receive the content: %s\n", buf);
                    reset_oneshot(epollfd, sockfd);
                    printf("reset the oneshot successfully\n");
                }
            }
            else 
                printf("something unknown happend\n");
        }
        sleep(1);
    }
    close(listenfd);
    return 0;
}

epoll：EPOLLONESHOT指定时，触发级别和边缘触发之间的差异

3 个答案: