epoll多路复用

最新推荐文章于 2025-06-14 17:53:38 发布
最新推荐文章于 2025-06-14 17:53:38 发布
阅读量289 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 4 linux c开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pengchengliu/article/details/80524928
本文介绍如何使用Epoll实现即时聊天应用，重点讲解Epoll的工作原理及其三种核心函数的使用方法，并通过示例代码展示了如何配置Epoll以提高聊天系统的响应速度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

epoll多路复用            
select效率随着描述符的增多，时间增多，因为内部是for循环。而epoll时间是固定的，不随着描述符的增多而增长。
在工作中不再使用select,而是用epoll.

epoll共有三个函数： 
a int epoll_create(int size);          //创建一个epoll句柄。现在epoll不限制数量，所以size现在失效了，写1就可以。
b int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);    //事件注册函数.dpfd是新创建的epoll句柄.op为EPOLL_CTL_ADD,表示                                                                                                     注册新的fd;为EPOLL_CTL_MOD,表示修改已经注册的fd的监听事件;为                                                                                                     EPOLL_CTL_DEL,表示从epfd中删除一个fd。fd是需要监听的fd。event                                                                                                     是告诉内核需要监听什么事。  
typedef union epoll_data{
  void *ptr;
  int fd;
  __uint32_t u32;
  __uint64_t u64;
}epoll_data_t;

 struct epoll_event{
  __uint32_t events;           //events可以是几个宏的集合。常用的有:EPOLLIN,表示对应的文件描述符可以读(包括对端SOCKET正常
                                               关闭)。EPOLLET,表示将EPOLL设为边缘触发(Edge Triggered)模式,这是相对于水平触发(Level Triggered)                                               来说的。
  epoll_data_t data;            
   };

c int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);  //等待事件的产生,类似于select()调用。epfd为要监听的句                                                                                    柄.从内核得到事件的集合保存到events中。maxevents告之内核这个events有多大                                                                                      (即,数组成员的个数).timeout是超时时间(毫秒,0会立即返回,-1将不确定,也有说法说                                                                                   是永久阻塞).触发了几个,返回值就是几。
例：用epoll实现即时聊天：    
//通过epoll来实现tcp即时通信:服务端   
#define NUM 10
int main(int argc,char* argv[]){
        if(argc!=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);  
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=bind(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
        if(-1==ret){
                perror("bind");
                return -1;
        }
        ret=listen(sfd,NUM);
        if(-1==ret){
                perror("listen");
                return -1;
        }
        int epfd=epoll_create(1);                         //创建epoll句柄   
        struct epoll_event event,evs[NUM+1];   //event保存注册的事件的信息，evs                                                                           用来保存epoll_wait监听到了的事件
        event.events=EPOLLIN;
        event.data.fd=sfd;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,sfd,&event);     //在epfd中注册sfd  
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        event.events=EPOLLIN;
        event.data.fd=0;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,0,&event);        //注册标准输入  
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        int i;
        int new_fd;
        char buf[128];
        int n;
        while(1){
                memset(evs,0,sizeof(evs));                 //每次都要清空,以便wait重新填写 
                ret=epoll_wait(epfd,evs,NUM+1,-1);//监听epfd,监听的结果放到evs数组                                                        中,数组的元素个数为NUM+1,-1表示一直监听.
                if(ret >0){
                        for(i=0;i<ret;i++){  //返回到了数组中，所以循环从evs重查看  
                                if(evs[i].events == EPOLLIN &&evs[i].data.fd == sfd){//新请求
                                        new_fd=accept(sfd,NULL,NULL);
                                        printf("new_fd=%d\n",new_fd);
                                        event.events=EPOLLIN;
                                        event.data.fd=new_fd;
                                        epoll_ctl(epfd,EPOLL_CTL_ADD,new_fd,&event);//注册
                                }
                                if(evs[i].events == EPOLLIN &&evs[i].data.fd == 0){   //输入
                                        memset(buf,0,sizeof(buf));
                                        n=read(0,buf,sizeof(buf));
                                        if(n>0){
                                                send(new_fd,buf,strlen(buf)-1,0);
                                        }else if(n==0){   //在新的一行输入ctrl+d,表示EOF  
                                                printf("bye\n");
                                                event.events=EPOLLIN;
                                                event.data.fd=new_fd;
                                                epoll_ctl(epfd,EPOLL_CTL_DEL,new_fd,&event);
                                                close(new_fd);      
                                        }
                                }
                                if(evs[i].events == EPOLLIN &&evs[i].data.fd == new_fd){//对                                                                                                   方向你发送消息      
                                        memset(buf,0,sizeof(buf));
                                        n=recv(new_fd,buf,sizeof(buf),0);   
                                        if(n>0){
                                                printf("%s\n",buf);
                                        }else if(n==0){                        //对方关闭连接了  
                                                printf("bye\n");
                                                event.events=EPOLLIN;
                                                event.data.fd=new_fd;
                                                epoll_ctl(epfd,EPOLL_CTL_DEL,new_fd,&event);
                                                close(new_fd);
                                                break;
                                        }
                                }      
                        }
                }
        }
        return 0;
}

//客户端   
int main(int argc,char** argv){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=connect(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
        if(-1==ret){
                perror("connect");
                return -1;
        }
        int epfd=epoll_create(1);            //创建epoll句柄 
        struct epoll_event event,evs[2];  //只监听2个
        event.events=EPOLLIN;
        event.data.fd=sfd;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,sfd,&event); //在epfd中注册sfd
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        event.events=EPOLLIN;
        event.data.fd=0;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,0,&event); //注册标准输入 
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        int i;
        char buf[128];
        int n;
        while(1){
                memset(evs,0,sizeof(evs));
                ret=epoll_wait(epfd,evs,2,-1); 
                if(ret>0){
                        for(i=0;i<ret;i++){
                                if(evs[i].events == EPOLLIN && evs[i].data.fd == 0){
                                        memset(buf,0,sizeof(buf));
                                        n=read(0,buf,sizeof(buf));                              
                                        if(n==0){                   //ctrl+d 结束 
                                                printf("bye\n");
                                                close(sfd);
                                                return 0;
                                        }
                                        n=send(sfd,buf,strlen(buf)-1,0);
                                        if(-1==n){
                                                perror("send");
                                                return -1;
                                        }
                                }
                                if(evs[i].events == EPOLLIN && evs[i].data.fd == sfd){
                                        memset(buf,0,sizeof(buf));
                                        n=recv(sfd,buf,sizeof(buf),0);                                    
                                        if(n > 0){
                                                printf("%s\n",buf);
                                        }else if(n==0){
                                                printf("bye\n");
                                                close(sfd);
                                                return 0;
                                        }
                                }
                        }
                }
        }
        return 0;
}

















注：在上面的程序中，buf一次能够读128个字符，但是如果对方一次给我传输256个字符，我第一次只能接收128个，然后输出。等到下一次while循环时，epoll_wait会继续触发，我再接收剩下的128个字符。这样不仅我每次只能接收一部分，要分成很多段来显示。而且给epoll_wait增加了压力。
        我们希望，1.针对客户端的每一次发送的数据，epoll_wait只触发一次。2.我们想一次把缓冲区里面的数据一次读完。

EPOLL 事件有两种模型:     
Edge Triggered (ET) 边缘触发：只有数据到来,才触发,不管缓存区中是否还有数据。 
Level Triggered (LT) 水平触发：只要有数据都会触发。

水平触发：当缓冲区有数据时，epoll_wait会不断得到触发。
如果发的长度大于buf的长度，会分成多段来打。。。

新的场景：
1.针对客户端的每一次发送的数据，epoll_wait只触发一次。
2.我们想一次把缓冲区里面的数据一次读完。
如果数据来了，我buf比较小，需要读多次。面临两个问题，1.

边缘触发：只有在上升沿的时候才触发。
改成之后：若客户端发送I come from china .则只触发一次。比如buf为10，则只发送I come fro
发送几次数据，我就响应几次。

例：将描述符的属性改为非阻塞    
void change_noblock(int fd){
        int status;
        status=fcntl(fd,F_GETFL);                //fcntl函数可以改变已打开的文件描述符性质。F_GETFL表示读取文件描述符状态。
        status=status|O_NONBLOCK;           //将状态改为非阻塞。要想再变回来，与上按位取反。
        int ret=fcntl(fd,F_SETFL,status);       //设置文件描述符状态，status为新状态。
        if(-1==ret){
                perror("fcntl");
                return;
        }
}

int main(){
        char buf[128]={0};
        change_noblock(0);                    //调用函数，将标准输入改为非阻塞，0为标准输入  
        int ret=read(0,buf,sizeof(buf));    //默认情况下是阻塞的，当执行到这里的时候，程序会卡住，等待键盘输入。如果输入字符，ret为                                                           成功读取的字节数，errno=0。如果输入ctrl+d,则ret=0,errno=0。按ctrl+d并不能让read退出，需要自                                                         己根据返回值，写判断语句让read退出。
                                                         //标准输入改为非阻塞之后，如果在read之前输入数据，read会正常读入。如果没有输入数据，read                                                         不会卡着等待输入，而是继续运行，此时ret=-1,errno=11.
        printf("ret=%d\n",ret);
        printf("errno=%d\n",errno);
        printf("buf=%s\n",buf);
        return 0;
}

read(0)函数返回值(标准输入阻塞的情况):
1. >0 成功读取的字节数，errno=0。
2. =0 到达文件尾。读标准输入时，按crtl +d，相当于EOF信号。此时errno=0。
3. -1  发生错误，通过errno确定具体错误值。
read(0)标准输入非阻塞的情况：
1. >0 成功读取的字节数
2. =0 到达文件尾。在阻塞前输入ctrl+d,相当于EOF。此时errno=0.
3. -1 有可能发生错误，通过errno确定具体错误值。有可能因为没有输入数据，read没有阻塞的返回值，此时返回值是-1，errno=11.     

recv(sfd)的返回值(网络描述符阻塞的情况):
1. >0 接收到数据大小
2. =0 正常连接关闭
3. -1 出错
对方没有发送数据，有没有关闭：则读端阻塞。
recv(sfd)的返回值(网络描述符非阻塞的情况):
1. >0 接收到数据大小
2. =0 正常连接关闭
3. -1 有可能是出错，通过errno确定具体错误值。有可能因为读取对应描述符,缓冲区为空,recv不阻塞,返回值是-1,errno=11(EAGAIN)  

例子： 用epoll实现即时聊天且：1.针对客户端的每一次发送的数据,epoll_wait只触发一次。2.一次把缓冲区里面的数据一次读完。
//通过epoll来实现tcp即时通信:服务端 
#define NUM 10
void change_noblock(int fd){            //将文件描述符的属性改为非阻塞  
        int status;
        status=fcntl(fd,F_GETFL);
        status=status|O_NONBLOCK;
        int ret=fcntl(fd,F_SETFL,status);
        if(-1==ret){
                perror("fcntl");
                return;
        }
}
int main(int argc,char* argv[]){
        if(argc!=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=bind(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
        if(-1==ret){
                perror("bind");
                return -1;
        }
        ret=listen(sfd,NUM);
        if(-1==ret){
                perror("listen");
                return -1;
        }
        int epfd=epoll_create(1);                                  //创建epoll句柄  
        struct epoll_event event,evs[NUM+1];
        event.events=EPOLLIN;                               
        event.data.fd=sfd;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,sfd,&event);      //在epfd中注册sfd   
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        event.events=EPOLLIN;                                              
        event.data.fd=0;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,0,&event);        //注册标准输入 
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        int i;
        int new_fd;
        char buf[10];
        int n;
        while(1){
                memset(evs,0,sizeof(evs));
                ret=epoll_wait(epfd,evs,NUM+1,-1);             //监听epfd 
                if(ret >0){
                        for(i=0;i<ret;i++){
                                if(evs[i].events == EPOLLIN &&evs[i].data.fd == sfd){ //新请求
                                        new_fd=accept(sfd,NULL,NULL);
                                        printf("new_fd=%d\n",new_fd);
                                        event.events=EPOLLIN|EPOLLET;//边沿触发的是否可读
                                        change_noblock(new_fd);     //改变描述符的属性为非阻塞
                                        event.data.fd=new_fd;
                                        epoll_ctl(epfd,EPOLL_CTL_ADD,new_fd,&event); //注册 
                                }
                                if(evs[i].events == EPOLLIN &&evs[i].data.fd == 0){ //输入
                                        memset(buf,0,sizeof(buf));
                                        n=read(0,buf,sizeof(buf));
                                        if(n>0){
                                                send(new_fd,buf,strlen(buf)-1,0);
                                        }else if(n==0){   //在新的一行输入ctrl+d,表示EOF 
                                                printf("bye\n");
                                                event.events=EPOLLIN;
                                                event.data.fd=new_fd;
                                                epoll_ctl(epfd,EPOLL_CTL_DEL,new_fd,&event);
                                                close(new_fd);      
                                        }
                                }
                                if(evs[i].events == EPOLLIN &&evs[i].data.fd == new_fd){
                                        while(1){            //通过循环直到把数据读空 
                                                memset(buf,0,sizeof(buf));
                                                n=recv(new_fd,buf,sizeof(buf),0);
                                                if(n>0){
                                                        printf("%s",buf);
                                                }else if(n == -1 && errno == EAGAIN){  //读空了 
                                                        break;
                                                }else if(n==0){              //对方关闭连接了
                                                        printf("bye\n");
                                                        event.events=EPOLLIN;
                                                        event.data.fd=new_fd;
                                                        epoll_ctl(epfd,EPOLL_CTL_DEL,new_fd,&event);
                                                        close(new_fd);
                                                        break;
                                                }
                                        }
                                        printf("\n");         //读完之后打印换行 
                                }      
                        }
                }
        }
        return 0;
}
//通过epoll来实现tcp即时通信:客户端 (未改进) 
int main(int argc,char** argv){
        if(argc !=3){
                printf("error args\n");
                return -1;
        }
        int sfd=socket(AF_INET,SOCK_STREAM,0);
        if(-1==sfd){
                perror("socket");
                return -1;
        }
        struct sockaddr_in ser;
        memset(&ser,0,sizeof(ser));
        ser.sin_family=AF_INET;
        ser.sin_port=htons(atoi(argv[2]));//一定要用htons
        ser.sin_addr.s_addr=inet_addr(argv[1]);
        int ret;
        ret=connect(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
        if(-1==ret){
                perror("connect");
                return -1;
        }
        int epfd=epoll_create(1);
        struct epoll_event event,evs[2];
        event.events=EPOLLIN;
        event.data.fd=sfd;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,sfd,&event);
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        event.events=EPOLLIN;
        event.data.fd=0;
        ret=epoll_ctl(epfd,EPOLL_CTL_ADD,0,&event);
        if(-1==ret){
                perror("epoll_ctl");
                return -1;
        }
        int i;
        char buf[128];
        int n;
        while(1){
                memset(evs,0,sizeof(evs));
                ret=epoll_wait(epfd,evs,2,-1);
                if(ret>0){
                        for(i=0;i<ret;i++){
                                if(evs[i].events == EPOLLIN && evs[i].data.fd == 0){
                                        memset(buf,0,sizeof(buf));
                                        n=read(0,buf,sizeof(buf));                              
                                        if(n==0){
                                                printf("bye\n");
                                                close(sfd);
                                                return 0;
                                        }
                                        n=send(sfd,buf,strlen(buf)-1,0);
                                        if(-1==n){
                                                perror("send");
                                                return -1;
                                        }
                                }
                                if(evs[i].events== EPOLLIN && evs[i].data.fd ==sfd){
                                        memset(buf,0,sizeof(buf));
                                        n=recv(sfd,buf,sizeof(buf),0);                                 
                                        if(n > 0){
                                                printf("%s\n",buf);
                                        }else if(n==0){
                                                printf("bye\n");
                                                close(sfd);
                                                return 0;
                                        }
                                }
                        }
                }
        }
        return 0;
}


































04 | Swoole 源码分析之 epoll 多路复用模块
A码农先森的专栏
03-31 869
epoll 在内部使用了红黑树的数据结构，红黑树是一个高效的数据结构。epoll 是解决 C10K 问题的利器，不仅是在 Swoole 中被应用，在很多的高性能服务中也有应用，例如：Nginx 服务等。Swoole 被称为高性能通信框架的关键原因，就是采用了 epoll 多路复用技术。
I/O多路复用之epoll
rotation博客
07-19 3517
epoll()是Linux特有的I/O复用函数。它在实现和使用上与select,poll有很大的差异。 关于select和poll可以参考：I/O多路复用之select , I/O多路复用之poll 首先，epoll使用一组函数来完成任务，而不是单个函数。其次，epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，从而无须像select和poll那样每次调用都要重复传入文件描述符集
【Linux】Linux多路复用-epoll
最新发布
Antonio915的博客
06-14 787
epoll是Linux高效I/O多路复用机制，通过epoll_create创建内核事件表（含红黑树和就绪队列），epoll_ctl注册/修改/删除监控事件，epoll_wait获取就绪事件。其核心优势在于：1）红黑树存储监控的FD，增删改查高效；2）回调机制将就绪事件自动加入就绪队列；3）仅返回就绪事件，避免遍历所有FD。相比select/poll，epoll更适合高并发场景，是高性能服务器的关键技术。
多路复用之——epoll
waywt1的博客
10-23 1598
epoll 与 select，poll 一样，其本质目的都是为了实现IO多路复用，将对多个文件描述符的等待时间重叠，提高 IO 的效率。但 epoll 不同的是，epoll 几乎解决了 select 和 poll 的所有缺点，具备之前所说的一切优点。
多路复用-epoll
u011215927的博客
04-22 934
一文学会应用epoll
多路复用之epoll
CherryXieのblog
07-03 1048
Epoll是Linux内核提供的一种I/O多路复用机制,是select和poll机制的改进版。
线程池epoll多路复用服务器c++
06-01
标题中的“线程池epoll多路复用服务器c++”是一个高级的计算机网络编程概念，涉及到C++语言实现的服务器架构。这个架构利用了线程池和epoll（I/O多路复用）技术来提高服务器处理并发连接的能力。下面我们将详细探讨...
基于Linux EPOLL多路复用的C++轻量级WebServer.zip
06-03
基于Linux EPOLL多路复用的C++轻量级WebServer C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括...
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
Tomcat NIO(2)-epoll多路复用
weixin_46073333的博客
07-07 1455
在上一篇文章里我们介绍了 tomcat io 主要包含那些 items，在这里我们主要介绍tomcat io 的基础-多路复用。tomcat 服务器(tomcat7以上)默认使用 jav...
epoll函数简介
Monster_ixx的博客
03-06 635
原博客地址：https://www.cnblogs.com/lojunren/p/3856290.html 文件描述符的创建 #include &amp;lt;sys/epoll.h&amp;gt; int epoll_create ( int size ); 在epoll早期的实现中，对于监控文件描述符的组织并不是使用红黑树，而是hash表。这里的size实际上已经没有意义。 注册监控事件 #include ...
多路复用----epoll
Hanani_Jia的博客
12-10 483
  上次我们介绍了多路复用IO的select。poll和select十分类似，把用户传入的数组拷贝到内核空间，然后查询每个fd的状态，如果对应设备就绪就放入等待队列中，如果没有设备就绪就把进程挂起，直到有设备就绪或者超时了，但是他比select好的一点是他没有数目限制，因为poll是基于链表来存储的，但是还是和select有相同的最大缺点：大量的fd数组从用户复制到内核，并且poll还有一个特点是...
IO多路复用-epoll
f593256的博客
01-26 1545
epoll 全称 eventpoll，是 linux 内核实现IO多路转接/复用（IO multiplexing）的一个实现。epoll是select和poll的升级版，相较于这两个前辈，epoll改进了工作方式，因此它更加高效。对于待检测集合select和poll是基于线性方式处理的，epoll是基于红黑树来管理待检测集合的。select和poll每次都会线性扫描整个待检测集合，集合越大速度越慢，epoll使用的是回调机制，效率高，处理效率也不会随着检测集合的变大而下降。
socket编程之epoll多路复用
我们的征途是星辰大海
08-01 1069
epoll的相关系统调用 1、int epoll_create(int size); 创建一个epoll描述符，该描述符占用一个fd值，程序退出前必须调用close()关闭，参数size为最大监听事件数 2、int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); epoll的事件注册函数，它不同于select(
IO多路复用之Epoll
Arthas的博客
02-19 352
IO多路复用的原理 IO多路复用的四个关键词：监控者、内核态、用户态、文件句柄。 IO多路复用的五个关键问题(步骤)： 1.监控者如何将文件句柄从用户态传递到内核态。 2.内核如何判断文件句柄的读写状态 3.内核如何通知监控者文件句柄可读可写 4.监控着如何找到可读写的文件句柄并通知应用态的应用程序 不同的多路复用接口都是基于对这四个问题的不同解答实现的。 5.继续循环时，监控者怎么...
select与epoll多路复用实践及jmeter性能测试
### epoll多路复用机制 epoll是Linux特有的I/O复用机制，提供了一种高效的方式来监视多个文件描述符。epoll解决了select的一些限制，适用于处理大量连接。 **epoll机制的主要优点包括：** - 可伸缩性：理论上epoll...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值