Linux下的I/O复用技术 — epoll如何使用(epoll_create、epoll_ctl、epoll_wait) 以及 LT/ET 使用过程解析

epoll如何使用?

0、为什么选择epoll

请参考上一篇博客:

epoll为什么更高效 ? epoll涉及的数据结构?

1、epoll的使用过程

在这里插入图片描述

1.0、相关基础概念(便于理解事件触发过程)

1、事件

  • 可读事件,当文件描述符关联的内核读缓冲区可读,则触发可读事件。
    (可读:内核缓冲区非空,有数据可以读取)

  • 可写事件,当文件描述符关联的内核写缓冲区可写,则触发可写事件。
    (可写:内核缓冲区不满,有空闲空间可以写入)

2、通知机制
通知机制,就是当事件发生的时候,则主动通知。通知机制的反面,就是轮询机制。

3、socket 和 文件描述符之间的关系

套接字也是文件。具体数据传输流程如下:

  • server端监听到有连接时,应用程序会请求内核创建Socket;

  • Socket创建好后会返回一个文件描述符给应用程序;

  • 当有数据包过来网卡时,内核会通过数据包的源端口,源ip,目的端口等在内核维护的一个ipcb双向链表中找到对应的Socket,并将数据包赋值到该Socket的缓冲区

  • 应用程序请求读取Socket中的数据时,内核就会将数据拷贝到应用程序的内存空间,从而完成读取Socket数据

注意:
操作系统针对不同的传输方式(TCP,UDP)会在内核中各自维护一个Socket双向链表,当数据包到达网卡时,会根据数据包的源端口,源ip,目的端口从对应的链表中找到其对应的Socket,并会将数据拷贝到Socket的缓冲区,等待应用程序读取。

想了解文件描述符(fd)是什么请参考此链接:
文件描述符(file descriptor)是什么?socket 和 文件描述符之间的关系?

4、服务器文件传输过程:server(服务器) ——》 client(客户)
在这里插入图片描述
当然:服务器接收客户的请求,红色箭头方向相反。

5、内核接收网络数据全过程

  • 1、计算机收到了对端传送的数据(步骤①);

  • 2、数据经由网卡传送到内存(步骤②);

  • 3、然后网卡通过中断信号通知cpu有数据到达,cpu执行中断程序(步骤③)。此处的中断程序主要有两项功能;

    • 先将网络数据写入到对应socket的接收缓冲区里面(步骤④);
    • 再唤醒进程A(步骤⑤),重新将进程A放入工作队列中。

在这里插入图片描述

注:
蓝色区域里面的等待队列:就是用户空间进程调用recv函数(读取数据)请求读取内核缓冲区内的数据,由于缓冲区数据没有准备好,所以处于等待状态(又称为阻塞状态)。

你有这样的疑问吗?操作系统如何知道网络数据对应于哪个socket?

因为一个socket对应着一个端口号,而网络数据包中包含了ip和端口的信息,内核可以通过端口号找到对应的socket。当然,为了提高处理速度,操作系统会维护端口号到socket的索引结构,以快速读取。

如何同时监视多个socket的数据?

哈哈哈,下面就该引出epoll了。epoll是一种I/O事件通知机制,是linux 内核实现IO多路复用的一个实现,在一个操作里同时监听多个输入输出源,在其中一个或多个输入输出源可用的时候返回,然后对其的进行读写操作。

1.1、epoll_create:文件描述符的创建

epoll_create的作用

  • epoll需要使用一个额外的文件描述符,来唯一标识内核中的这个事件表。 这个文件描述符使用如下epoll_create函数来创建;
  • epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中,从而无须像select和poll那样每次调用都要重复传入文件描述符集或事件集。
  • 调用epoll_create时,内核除了帮我们在epoll文件系统里建了个file结点(epoll_create创建的文件描述符),在内核cache里建了个 红黑树用于存储以后epoll_ctl传来的socket外,还会再建立一个list链表,用于存储准备就绪的事件.(概括就是:调用epoll_create方法时,内核会跟着创建一个eventpoll对象)
    在这里插入图片描述
  • eventpoll对象也是文件系统中的一员,和socket一样,它也会有等待队列。
  • 创建一个代表该epolleventpoll对象是必须的,因为内核要维护“就绪列表”等数据,“就绪列表”可以作为eventpoll的成员。
struct eventpoll
{
    spin_lock_t lock;            //对本数据结构的访问
    struct mutex mtx;            //防止使用时被删除
    wait_queue_head_t wq;        //sys_epoll_wait() 使用的等待队列
    wait_queue_head_t poll_wait; //file->poll()使用的等待队列
    struct list_head rdllist;    //事件满足条件的链表
    struct rb_root rbr;          //用于管理所有fd的红黑树
    struct epitem *ovflist;      //将事件到达的fd进行链接起来发送至用户空间
}

总结:
epoll_create创建额外的文件描述符,来唯一标识内核中的这个内核事件表(eventpoll对象)

epoll_create函数原型

该函数返回的文件描述符将用作其他所有epoll系统调用的第一个参数,以指定要访问的内核事件表。

#include<sys/epoll.h>
int epoll_create(int size);

返回值:

  • 返回文件描述符epollfd

参数说明:

  • size参数现在并不起作用,只是给内核一个提示,告诉内核应该如何为内部数据结构划分初始大小。

需要注意的是:

这个文件描述符也会占用一个fd值,在linux下如果查看/proc/进程id/fd/,能够看到这个fd,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽

1.2、epoll_ctl:注册监控事件

epoll_ctl的作用

创建epoll对象后,可以用epoll_ctl添加或删除所要监听的socket。以添加socket为例,如下图,如果通过epoll_ctl添加sock1、sock2和sock3的监视,内核会将eventpoll添加到这三个socket的等待队列中。
在这里插入图片描述
注意:

当socket收到数据后,中断程序会操作eventpoll对象,而不是直接操作进程。

epoll_ctl函数原型

操作epoll的内核事件表

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

返回值:

  • 成功返回0,不成功返回-1并设置errno。

参数说明:

  • 1、epfd :epoll_create()的返回值;
  • 2、op : 指定操作类型。操作类型有如下3种:
    • EPOLL_CTL_ADD:注册新的fd到epfd中;
    • EPOLL_CTL_MOD:修改已经注册的fd的监听事件;
    • EPOLL_CTL_DEL:从epfd中删除一个fd;
  • 3、fd:是需要监听的fd
  • 4、event:告诉内核需要监听什么事,指定事件,它是epoll_event结构指针类型。
    • epoll_event的定义如下:
struct epoll_event {
  __uint32_t events;  /* Epoll 事件 */
  epoll_data_t data;  /* 用户数据 */
};

其中events成员描述事件类型,具体如下:

事件描述
EPOLLIN可读取非高优先级数据(重要,必用)
EPOLLPRI可读取高优先级数据
EPOLLOUT普通数据可写 (重要,必用)
EPOLLHUP本端描述符产生一个挂断事件,默认监测事件
EPOLLET采用边沿触发事件通知(重要)
EPOLLONESHOT在完成事件通知后禁用检查
EPOLLRDHUP套接字对端关闭
EPOLLERR有错误发生

data成员用于存储用户数据,其类型epoll_data_t的定义如下:

typedef union epoll_data
{
    void* ptr;              //指定与fd相关的用户数据
    int fd;                 //指定事件所从属的目标文件描述符
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

epoll_data_t是一个共用体,其4个成员中使用最多的是fd,它指定事件所从属的目标文件描述符。ptr成员可以用来指定与fd相关的用户数据。但由于epoll_data_t是一个共用体,我们不能同时使用其ptr成员和fd成员,因此,如果要将文件描述符和用户数据关联起来,以实现快速的数据访问,只能放弃使用epoll_data_t的fd成员,而在ptr指向的用户数据中包含fd。

1.3、epoll_wait:事件等待,返回就绪事件

epoll_wait的作用
当socket收到数据后,中断程序会给eventpoll的“就绪列表”添加socket引用。如下图展示的是sock2和sock3收到数据后,中断程序让rdlist引用这两个socket,而不是像select轮询所有的sock。
在这里插入图片描述
eventpoll对象相当于是socket和进程之间的中介,socket的数据接收并不直接影响进程,而是通过改变eventpoll的就绪列表来改变进程状态。

当程序执行到epoll_wait时,如果rdlist已经引用了socket,那么epoll_wait直接返回,如果rdlist为空,阻塞进程,如下:

  • 1、在某时刻进程A运行到了epoll_wait语句。如下图所示,内核会将进程A放入eventpoll的等待队列中,阻塞进程。

在这里插入图片描述

  • 2、当socket接收到数据,中断程序一方面修改rdlist,另一方面唤醒eventpoll等待队列中的进程,进程A再次进入运行状态(如下图)。也因为rdlist的存在,进程A可以知道哪些socket发生了变化。
    在这里插入图片描述

epoll_wait函数原型
它在一段超时时间内等待一组文件描述符上的事件,阻塞等待注册的事件发生,返回事件的数目,其原型如下:

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

返回值:

  • 成功时返回就绪文件描述符个数,失败时返回-1并设置errno。

参数说明:

  • 1、epfd :epoll_create()的返回值;
  • 2、events: 用来记录被触发的events(结构参考epoll_ctl),其大小受制于maxevents
  • 3、maxevents: 设定最多监听多少个事件,必须大于0,一般设定为65535
  • 4、timeout:在函数调用中阻塞时间上限,单位是ms
    • timeout = -1:表示调用将一直阻塞,直到有文件描述符进入ready状态或者捕获到信号才返回;
    • timeout = 0:用于非阻塞检测是否有描述符处于ready状态,不管结果怎么样,调用都立即返回;
    • timeout > 0:表示调用将最多持续timeout时间,如果期间有检测对象变为ready状态或者捕获到信号则返回,否则直到超时。

timeout参数设计技巧问题?

  • 1、设置为-1,程序阻塞在此,后续任务没法执行。
  • 2、设置为0,程序能继续跑,但即使没事件时,程序也在空转,十分占用cpu时间片,我测试时每个进程都是60+%的cpu占用时间。
  • 综上,我们给出比较好的设置方法:将其设置为1,但还没完,因为即使这样设置,处理其它任务时,在每次循环都会在这浪费1ms的阻塞时间,多次循环后性能损失就比较明显了。
    • 为了避免该现象,我们通常向epoll再添加一个fd,我们有其它任务要执行时直接向该fd随便写入一个字节,将epoll唤醒从而跳过阻塞时间。没任务时epoll超过阻塞时间1ms也会自动挂起,不会占用cpu,两全其美。
    • int eventfd(unsigned int initval, int flags),linux中是一个较新的进程通信方式,可以通过它写入字节。

2、LT/ET 使用过程

2.1 LT水平触发(Level Triggered)

  • Level Triggered (LT) 水平触发
    • socket接收缓冲区不为空 ,说明有数据可读, 读事件一直触发
    • socket发送缓冲区不满 ,说明可以继续写入数据 ,写事件一直触发
    • 符合思维习惯,epoll_wait返回的事件就是socket的状态

LT的处理过程:

  • 1、accept一个连接,添加到epoll中监听EPOLLIN事件 .(注意这里没有关注EPOLLOUT事件
  • 2、当EPOLLIN事件到达时,read fd中的数据并处理 .
  • 3、当需要写出数据时,把数据write到fd中;如果数据较大,无法一次性写出,那么在epoll中监听EPOLLOUT事件 .
  • 4、当EPOLLOUT事件到达时,继续把数据write到fd中;如果数据写出完毕,那么在epoll中关闭EPOLLOUT事件
//LT模式的工作流程
void lt( epoll_event* events, int number, int epollfd, int listenfd )
{
    char buf[ BUFFER_SIZE ];
    for ( int i = 0; i < number; i++ )
    {
        int sockfd = events[i].data.fd;
        if ( sockfd == listenfd )
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof( client_address );
            int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
            addfd( epollfd, connfd, false );
        }
        else if ( events[i].events & EPOLLIN )
        {
            //只要socket读缓存中还有未读出的数据,这段代码就被触发
            printf( "event trigger once\n" );
            memset( buf, '\0', BUFFER_SIZE );
            int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
            if( ret <= 0 )
            {
                close( sockfd );
                continue;
            }
            printf( "get %d bytes of content: %s\n", ret, buf );
        }
        else
        {
            printf( "something else happened \n" );
        }
    }
}

2.2 ET边沿触发(Edge Triggered )

  • Edge Triggered (ET) 边沿触发
    • socket的接收缓冲区状态变化时触发读事件,即空的接收缓冲区刚接收到数据时触发读事件(从无到有
    • socket的发送缓冲区状态变化时触发写事件,即满的缓冲区刚空出空间时触发读事件(从有到无
    • 仅在状态变化时触发事件

ET的处理过程:

  • 1、accept一个一个连接,添加到epoll中监听EPOLLIN|EPOLLOUT事件()
  • 2、当EPOLLIN事件到达时,read fd中的数据并处理,read需要一直读,直到返回EAGAIN为止
  • 3、当需要写出数据时,把数据write到fd中,直到数据全部写完,或者write返回EAGAIN
  • 4、当EPOLLOUT事件到达时,继续把数据write到fd中,直到数据全部写完,或者write返回EAGAIN

从ET的处理过程中可以看到,ET的要求是需要一直读写,直到返回EAGAIN,否则就会遗漏事件。而LT的处理过程中,直到返回EAGAIN不是硬性要求,但通常的处理过程都会读写直到返回EAGAIN,但LT比ET多了一个开关EPOLLOUT事件的步骤

当我们使用ET模式的epoll时,我们应该按照以下规则设计:

  • 1、在接收到一个I/O事件通知后,立即处理该事件。程序在某个时刻应该在相应的文件描述符上尽可能多地执行I/O。
  • 2、在ET模式下,在使用epoll_ctl注册文件描述符的事件时,应该把描述符设置为非阻塞的(非常重要)
    • 因为程序采用循环(ET里面采用while循环,看清楚呦,LE是if判断)来对文件描述符执行尽可能多的I/O,而文件描述符又被设置为可阻塞的,那么最终当没有更多的I/O可执行时,I/O系统调用就会阻塞。基于这个原因,每个被检查的文件描述符通常应该置为非阻塞模式,在得到I/O事件通知后重复执行I/O操作,直到相应的系统调用(比如read(),write())以错误码EAGAIN或EWOULDBLOCK的形式失败。
//ET模式的工作流程
void et( epoll_event* events, int number, int epollfd, int listenfd )
{
    char buf[ BUFFER_SIZE ];
    for ( int i = 0; i < number; i++ )
    {
        int sockfd = events[i].data.fd;
        if ( sockfd == listenfd )
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof( client_address );
            int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
            addfd( epollfd, connfd, true );
        }
        else if ( events[i].events & EPOLLIN )
        {
            //这段代码不会被重复触发,所以我们循环读取数据,以确保把socket读缓存中的所有数据读出
            printf( "event trigger once\n" );
            while( 1 )
            {
                memset( buf, '\0', BUFFER_SIZE );
                int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
                if( ret < 0 )
                {
                    //对于非阻塞IO,下面条件成立表示数据已经全部读取完毕。
                    //此后,epoll就能再次触发sockfd上的EPOLLIN事件,已驱动下一次读操作
                    if( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) )
                    {
                        printf( "read later\n" );
                        break;
                    }
                    close( sockfd );
                    break;
                }
                else if( ret == 0 )
                {
                    close( sockfd );
                }
                else
                {
                    printf( "get %d bytes of content: %s\n", ret, buf );
                }
            }
        }
        else
        {
            printf( "something else happened \n" );
        }
    }
}

3、使用案例

Server.cpp

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

#define SOCKET_PORT 9999
#define EPOLL_SIZE 10

int main(int argc, char *argv[])
{
    int server_fd;
    int client_fd;
    int epfd;
    
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));
    addr.sin_family = AF_INET;
    
    if (argc == 2){
        addr.sin_addr.s_addr = inet_addr(argv[1]);
        addr.sin_port = htons(SOCKET_PORT);
    }else if(argc==3){
        addr.sin_addr.s_addr = inet_addr(argv[1]);
        addr.sin_port = htons(atoi(argv[2]));
    }else{
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        addr.sin_port = htons(SOCKET_PORT); 
    }
    
    server_fd = socket(PF_INET,SOCK_STREAM,0);
    if (server_fd < 0){
        std::cout<<"Create Socket Errors, "<<server_fd<<std::endl;
        exit(server_fd);
    }
    
    if (bind(server_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) < 0) 
    {
        perror("bind error");
        return -1;
    }
    
    if (listen(server_fd, 10)<0)
    {
        perror("listen error");
        return -1;
    }else{
        printf("Stared the Socket: %s:%d\n",
               inet_ntoa(addr.sin_addr),
               ntohs(addr.sin_port));
    }
    
    epfd = epoll_create(EPOLL_SIZE);
    if (epfd < 0)
    {
        perror("Epoll Create");
        exit(-1);
    }
    
    struct epoll_event ev;
    struct epoll_event events[EPOLL_SIZE];
    ev.data.fd = server_fd;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev);
    fcntl(server_fd, F_SETFL, fcntl(server_fd, F_GETFD, 0)| O_NONBLOCK);
    
    while (1)
    {
        int epoll_events_count = epoll_wait(epfd, events, EPOLL_SIZE, -1);
        if (epoll_events_count < 0)
        {
            perror("epoll failed");
            break;
        }
        printf("epoll_events_count = %d\n", epoll_events_count);
        for (int i=0;i < epoll_events_count;i++)
        {
            if (events[i].data.fd==server_fd&&(events[i].events & EPOLLIN))
            {
                struct sockaddr_in remote_addr;
                
                socklen_t socklen = sizeof(struct sockaddr_in);
                client_fd = accept(server_fd, (struct sockaddr *)&remote_addr, &socklen);
                if (client_fd < 0)
                {
                    perror("accept error");
                }
                printf("client connection from: %s : % d(IP : port), "
                       "clientfd = %d \n",
                       inet_ntoa(remote_addr.sin_addr),
                       ntohs(remote_addr.sin_port),
                       client_fd);
                
                ev.data.fd = client_fd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);
                
                fcntl(client_fd, F_SETFL,
                      fcntl(client_fd, F_GETFD, 0)| O_NONBLOCK);
                send(client_fd,"Welcome to My server",21,0);
            }else{ 
                char buffer[1024];
                int len;
                if ((len=recv(events[i].data.fd,buffer,sizeof(buffer), 0))>0)
                {
                    send(events[i].data.fd,"Welcome to My server\n",21,0);
                    printf("%s fd %d \n",buffer,events[i].data.fd);
                    
                    //close(client_fd);
                }else{
                    printf("client offline with: "
                           "clientfd = %d \n",
                           events[i].data.fd);
                }
            }
        }
    }
    close(server_fd);
    close(epfd);
    return 0;                                                                   
}

Client.cpp

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

//#include <memory.h>  //menset
#include <sys/epoll.h>
#include <fcntl.h>

#define EPOLL_SIZE 10

int main(int argc, char *argv[])
{
    int size;
    int client_fd;
    
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));
    addr.sin_family = AF_INET;
    
    if (argc == 3){
        addr.sin_addr.s_addr = inet_addr(argv[1]);
        addr.sin_port = htons(atoi(argv[2]));
    }else{
        printf("The host ip and port is falied.\n");
        exit(-1);
    }
    
    client_fd = socket(PF_INET,SOCK_STREAM,0);
    
    if (client_fd < 0){
        std::cout<<"Create Socket Errors, "<<client_fd<<std::endl;
        exit(client_fd);
    }
    
    size = connect(client_fd, (struct sockaddr *)&addr,
                   sizeof(struct sockaddr));
    if (size < 0)
    {
        perror("connect error");
    }
    printf("Connect client: %s:%d \n",inet_ntoa(addr.sin_addr),
           ntohs(addr.sin_port));
    
    int epfd;
    epfd = epoll_create(EPOLL_SIZE);
    struct epoll_event ev;
    
    ev.data.fd = client_fd;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);
    fcntl(client_fd, F_SETFL, fcntl(client_fd, F_GETFD, 0)| O_NONBLOCK);
    
    char buffer[1024];
    struct epoll_event events[EPOLL_SIZE];
    
    int len;
    while (1)
    {
        int epoll_events_count = epoll_wait(epfd, events, EPOLL_SIZE, -1);
        if (epoll_events_count<0)
        {
            perror("Epoll wait");
            exit(-1);
        }
        
        for (int i=0;i<epoll_events_count;i++)
        {
            printf("client fd %d, event fd %d \n",client_fd,
                   events[i].data.fd);
            len = recv(client_fd, buffer, sizeof(buffer), 0);
            if (len > 0)
            {
                printf("%s",buffer);
            }
            sleep(3);
            send(client_fd,"Welcome to My client",21,0);
        }
    }
    return 0;
}

部分函数说明

atoi 将字符串转化为int
int atoi (const char * str)

atol 将字符串转化为long
long int atol ( const char * str )

4、常问面试问题

参考上一篇博客:Epoll常见面试问题,LT和ET区别?将socket设为非阻塞?正确的读写方式?关于epoll的数据结构?epoll与select、poll的对比?

参考

1、https://www.cnblogs.com/kefeiGame/p/7246942.html
2、https://zhuanlan.zhihu.com/p/21374980
3、https://www.cnblogs.com/lojunren/p/3856290.html
4、https://bbs.gameres.com/thread_842984_1_1.html
5、https://blog.csdn.net/ChaseRaod/article/details/79361025
6、https://www.zhihu.com/question/23614342/answer/184513538

  • 30
    点赞
  • 88
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
这三个函数都是与 Linux 系统中的 epoll I/O 多路复用机制相关的函数。 1. `epoll_create` 函数用于创建一个 epoll 文件描述符,返回值即为该文件描述符。该函数的原型为: ```c int epoll_create(int size); ``` 其中参数 `size` 表示 epoll 实例中能够关注的最大文件描述符数目,一般可以设置为任意大于 0 的数。 2. `epoll_ctl` 函数用于控制 epoll 实例中的文件描述符,可以用于添加、修改和删除文件描述符的关注事件。该函数的原型为: ```c int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); ``` 其中 `epfd` 参数表示 epoll 文件描述符,`op` 参数表示操作类型,可选的取值有 `EPOLL_CTL_ADD`、`EPOLL_CTL_MOD` 和 `EPOLL_CTL_DEL`,分别表示添加、修改和删除操作。`fd` 参数表示需要被添加、修改或删除的文件描述符,`event` 参数表示需要关注的事件,包括事件类型和事件数据等信息。 3. `epoll_wait` 函数用于等待 epoll 实例中的文件描述符上发生关注的事件,该函数会阻塞进程直到有事件发生。该函数的原型为: ```c int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout); ``` 其中 `epfd` 参数表示 epoll 文件描述符,`events` 参数表示事件数组,用于存储返回的事件信息,`maxevents` 参数表示最大返回的事件数目,`timeout` 参数表示超时时间,单位为毫秒,如果设置为 -1 则表示永久阻塞直到有事件发生。 总的来说,epoll I/O 多路复用机制通过 `epoll_create` 函数创建一个 epoll 实例,并通过 `epoll_ctl` 函数控制实例中的文件描述符。然后通过 `epoll_wait` 函数等待文件描述符上发生关注的事件,从而实现高效的 I/O 多路复用。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值