Linux select/epoll网络模型

最新推荐文章于 2026-05-31 16:26:54 发布
原创 最新推荐文章于 2026-05-31 16:26:54 发布 · 634 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细解析了Linux环境下epoll和select网络模型的优劣，并提供了基于epoll模型的TCP服务器C代码实现，同时展示了如何使用epoll进行高效的数据处理。

select,epoll网络模型经常在面试中出现,epoll是对poll的优化,是linux下最优秀的网络模型

epoll优点:

# 相对select,没有最大并发数限制 /proc/sys/file-max

# 数据传递(用户空间跟内核空间)通过共享内存(mmap)方式

# epoll_wait 直接返回被触发的fd对应的一块buffer,不需要遍历所有的fd

 

一.Linux select模型

流程:

1. 声明数组fd_A,添加多个socket client fd

2. 监听端口

3. 将sock_fd 和 数组fd不为0描述符放入select将检查的fd_set中

4. 处理 fdsr可以接收数据的连接; 如是sock_fd,添加新连接至fd_A;  

详见: http://blog.chinaunix.net/uid-25808509-id-2233262.html

 

C代码  收藏代码
  1. // select_tcp_server.c     
  2. #include <stdio.h>    
  3. #include <stdlib.h>    
  4. #include <unistd.h>    
  5. #include <errno.h>    
  6. #include <string.h>    
  7. #include <sys/types.h>    
  8. #include <sys/socket.h>    
  9. #include <netinet/in.h>    
  10. #include <arpa/inet.h>    
  11.     
  12. #define MYPORT 1234    // the port users will be connecting to    
  13. #define BACKLOG 5     // how many pending connections queue will hold    
  14. #define BUF_SIZE 200    
  15.     
  16. int fd_A[BACKLOG];    // accepted connection fd    
  17. int conn_amount;    // current connection amount    
  18.     
  19. void showclient()    
  20. {    
  21.     int i;    
  22.     printf("client amount: %d\n", conn_amount);    
  23.     for (i = 0; i < BACKLOG; i++) {    
  24.         printf("[%d]:%d ", i, fd_A[i]);    
  25.     }    
  26.     printf("\n\n");    
  27. }    
  28.     
  29. int main(void)    
  30. {    
  31.     int sock_fd, new_fd;  // listen on sock_fd, new connection on new_fd    
  32.     struct sockaddr_in server_addr;    // server address information    
  33.     struct sockaddr_in client_addr; // connector's address information    
  34.     socklen_t sin_size;    
  35.     int yes = 1;    
  36.     char buf[BUF_SIZE];    
  37.     int ret;    
  38.     int i;    
  39.     
  40.     if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {    
  41.         perror("socket");    
  42.         exit(1);    
  43.     }    
  44.     
  45.     if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {    
  46.         perror("setsockopt");    
  47.         exit(1);    
  48.     }    
  49.         
  50.     server_addr.sin_family = AF_INET;         // host byte order    
  51.     server_addr.sin_port = htons(MYPORT);     // short, network byte order    
  52.     server_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP    
  53.     memset(server_addr.sin_zero, '\0', sizeof(server_addr.sin_zero));    
  54.     
  55.     if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {    
  56.         perror("bind");    
  57.         exit(1);    
  58.     }    
  59.     
  60.     if (listen(sock_fd, BACKLOG) == -1) {    
  61.         perror("listen");    
  62.         exit(1);    
  63.     }    
  64.     
  65.     printf("listen port %d\n", MYPORT);    
  66.     
  67.     fd_set fdsr;    
  68.     int maxsock;    
  69.     struct timeval tv;    
  70.     
  71.     conn_amount = 0;    
  72.     sin_size = sizeof(client_addr);    
  73.     maxsock = sock_fd;    
  74.     while (1) {    
  75.         // initialize file descriptor set    
  76.         FD_ZERO(&fdsr);    
  77.         FD_SET(sock_fd, &fdsr);    
  78.     
  79.         // timeout setting    
  80.         tv.tv_sec = 30;    
  81.         tv.tv_usec = 0;    
  82.     
  83.         // add active connection to fd set    
  84.         for (i = 0; i < BACKLOG; i++) {    
  85.             if (fd_A[i] != 0) {    
  86.                 FD_SET(fd_A[i], &fdsr);    
  87.             }    
  88.         }    
  89.     
  90.         ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);    
  91.         if (ret < 0) {    
  92.             perror("select");    
  93.             break;    
  94.         } else if (ret == 0) {    
  95.             printf("timeout\n");    
  96.             continue;    
  97.         }    
  98.     
  99.         // check every fd in the set    
  100.         for (i = 0; i < conn_amount; i++) {    
  101.             if (FD_ISSET(fd_A[i], &fdsr)) {    
  102.                 ret = recv(fd_A[i], buf, sizeof(buf), 0);    
  103.                 if (ret <= 0) {        // client close    
  104.                     printf("client[%d] close\n", i);    
  105.                     close(fd_A[i]);    
  106.                     FD_CLR(fd_A[i], &fdsr);    
  107.                     fd_A[i] = 0;    
  108.                 } else {        // receive data    
  109.                     if (ret < BUF_SIZE)    
  110.                         memset(&buf[ret], '\0', 1);    
  111.                     printf("client[%d] send:%s\n", i, buf);    
  112.                 }    
  113.             }    
  114.         }    
  115.     
  116.         // check whether a new connection comes    
  117.         if (FD_ISSET(sock_fd, &fdsr)) {    
  118.             new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);    
  119.             if (new_fd <= 0) {    
  120.                 perror("accept");    
  121.                 continue;    
  122.             }    
  123.     
  124.             // add to fd queue    
  125.             if (conn_amount < BACKLOG) {    
  126.                 fd_A[conn_amount++] = new_fd;    
  127.                 printf("new connection client[%d] %s:%d\n", conn_amount,    
  128.                         inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));    
  129.                 if (new_fd > maxsock)    
  130.                     maxsock = new_fd;    
  131.             }    
  132.             else {    
  133.                 printf("max connections arrive, exit\n");    
  134.                 send(new_fd, "bye", 4, 0);    
  135.                 close(new_fd);    
  136.                 break;    
  137.             }    
  138.         }    
  139.     
  140.         showclient();    
  141.     }    
  142.     
  143.     // close other connections    
  144.     for (i = 0; i < BACKLOG; i++) {    
  145.         if (fd_A[i] != 0) {    
  146.             close(fd_A[i]);    
  147.         }    
  148.     }    
  149.     
  150.     exit(0);    
  151. }  

 

二. linux epoll模型

C代码  收藏代码
  1. //epoll_tcp_server.c  
  2. #include <stdio.h>  
  3. #include <unistd.h>  
  4. #include <netinet/in.h>  
  5. #include <sys/socket.h>  
  6. #include <sys/epoll.h>  
  7. #include <arpa/inet.h>  
  8. #include <fcntl.h>  
  9. #include <errno.h>  
  10. #include <time.h>  
  11. #include <list>  
  12. #include <stdlib.h>  
  13. #include <string.h>  
  14.   
  15.   
  16. #define BUF_SIZE 1024  
  17. #define SERV_PORT 1234  
  18. #define EPOLL_RUN_TIMEOUT -1  
  19. #define EPOLL_SIZE 10000  
  20.   
  21. #define STR_WELCOME "welcome to seChat! You ID is:Client #%d"  
  22. #define STR_MESSAGE "Client #%d>>%s"  
  23. #define STR_NOONE_CONNECTED "Noone connected to server except you"  
  24.   
  25. #define CHK(eval) if(eval<0){ perror("eval"); exit(-1); }  
  26. #define CHK2(res,eval) if((res = eval)<0){ perror("eval"); exit(-1); }  
  27.   
  28.   
  29. using namespace std;  
  30.   
  31. list<int> clients_list;  
  32.   
  33.   
  34. // 设置非阻塞  
  35. int SetNoblocking(int sockfd)  
  36. {  
  37.     CHK(fcntl(sockfd,F_SETFL,fcntl(sockfd,F_GETFD,0)|O_NONBLOCK));  
  38.     return 0;  
  39. }  
  40.   
  41.   
  42. // 处理消息  
  43. int HandleMsg(int client)  
  44. {  
  45.     char buf[BUF_SIZE],message[BUF_SIZE];  
  46.     bzero(buf,BUF_SIZE);  
  47.     bzero(message,BUF_SIZE);  
  48.   
  49.     int len;  
  50.     CHK2(len,recv(client,buf,BUF_SIZE,0));  
  51.     printf("Accept:%s\n",buf);  
  52.   
  53.     // 客户端关闭  
  54.     if(len==0)  
  55.     {  
  56.         CHK(close(client));  
  57.         clients_list.remove(client);  
  58.     }else  
  59.     {  
  60.         // 向客户端发送消息  
  61.         if(clients_list.size()==1)  
  62.         {  
  63.             CHK(send(client,STR_NOONE_CONNECTED,strlen(STR_NOONE_CONNECTED),0));  
  64.             return len;  
  65.         }  
  66.   
  67.         sprintf(message,STR_MESSAGE,client,buf);  
  68.   
  69.         list<int>::iterator it;  
  70.         for(it = clients_list.begin(); it!=clients_list.end();it++)  
  71.         {  
  72.             if(*it!=client)  
  73.             {  
  74.                 CHK(send(*it,message,BUF_SIZE,0));  
  75.             }  
  76.         }  
  77.     }  
  78.   
  79.     return len;  
  80. }  
  81.   
  82.   
  83. int main(int argc,char **argv)  
  84. {  
  85.     int listener;  
  86.     struct sockaddr_in addr,their_addr;  
  87.     addr.sin_family = AF_INET;  
  88.     addr.sin_port = htons(SERV_PORT);  
  89.     addr.sin_addr.s_addr = inet_addr("127.0.0.1");  
  90.     socklen_t socklen;  
  91.     socklen = sizeof(struct sockaddr_in);  
  92.   
  93.     static struct epoll_event ev,events[EPOLL_SIZE];  
  94.     ev.events = EPOLLIN|EPOLLET; // 读感兴趣,边沿触发   
  95.   
  96.     char message[BUF_SIZE];  
  97.     int epfd;  
  98.     clock_t tStart;  
  99.     int client,res,epoll_events_count;  
  100.   
  101.     CHK2(listener,socket(AF_INET,SOCK_STREAM,0));  
  102.     SetNoblocking(listener);  
  103.   
  104.     CHK(bind(listener,(struct sockaddr*)&addr,sizeof(addr)));  
  105.     CHK(listen(listener,1));  
  106.   
  107.     CHK2(epfd,epoll_create(EPOLL_SIZE));  
  108.     ev.data.fd = listener;  
  109.     CHK(epoll_ctl(epfd,EPOLL_CTL_ADD,listener,&ev));  
  110.   
  111.     while(1)  
  112.     {  
  113.         CHK2(epoll_events_count,epoll_wait(epfd,events,EPOLL_SIZE,EPOLL_RUN_TIMEOUT));  
  114.   
  115.         tStart = clock();  
  116.   
  117.         int i;  
  118.         for(i=0;i<epoll_events_count;i++)  
  119.         {  
  120.             if(events[i].data.fd == listener) // new connection  
  121.             {  
  122.                 CHK2(client,accept(listener,(struct sockaddr*)&their_addr,&socklen));  
  123.   
  124.                 SetNoblocking(client);  
  125.                 ev.data.fd = client;  
  126.   
  127.                 CHK(epoll_ctl(epfd,EPOLL_CTL_ADD,client,&ev)); // register  
  128.   
  129.                 clients_list.push_back(client); // add to list  
  130.   
  131.                 bzero(message,BUF_SIZE);  
  132.                 res = sprintf(message,STR_WELCOME,client);  
  133.                 CHK2(res,send(client,message,BUF_SIZE,0));  
  134.             }else  
  135.             {  
  136.                 CHK2(res,HandleMsg(events[i].data.fd));  
  137.             }  
  138.   
  139.             printf("Statistics: %d events handled at: %.2fs\n",epoll_events_count,(double)(clock()-tStart)/CLOCKS_PER_SEC); }  
  140.     }  
  141.   
  142.     close(listener);  
  143.     close(epfd);  
  144.   
  145.     return 0;  
  146. }  

 

    TCP测试客户端,模拟1万个连接

C代码  收藏代码
  1. // huge_tcp_client.c   
  2. #define EPOLL_SIZE 10000  
  3. using namespace std;  
  4.   
  5. char message[BUF_SIZE];  
  6. list<int> list_of_clients;  
  7. int res;  
  8. clock_t tStart;  
  9.   
  10. int main(int argc,char **argv)  
  11. {  
  12.     int sock;  
  13.     struct sockaddr_in addr;  
  14.     addr.sin_family = AF_INET;  
  15.     addr.sin_port = htons(SERV_PORT);  
  16.     addr.sin_addr.s_addr = inet_addr("127.0.0.1");  
  17.   
  18.     tStart = clock();  
  19.   
  20.     for(int i=0;i<EPOLL_SIZE;i++)  
  21.     {  
  22.         CHK2(sock,socket(AF_INET,SOCK_STREAM,0));  
  23.         CHK(connect(sock,(struct sockaddr*)&addr,sizeof(addr))<0);  
  24.         list_of_clients.push_back(sock);  
  25.   
  26.         bzero(&message,BUF_SIZE);  
  27.         CHK2(res,recv(sock,message,BUF_SIZE,0));  
  28.         printf("Accept:%s\n",message);    
  29.     }  
  30.   
  31.     list<int>::iterator it;  
  32.     for(it = list_of_clients.begin();it!=list_of_clients.end();it++)  
  33.     {  
  34.         close(*it);  
  35.     }  
  36.   
  37.     printf("Test passed:.2fs\n",(double)(clock()-tStart)/CLOCKS_PER_SEC);  
  38.     printf("Total server connections:%d\n",EPOLL_SIZE);  
  39.   
  40.     return 0;  
  41. }  

 

hbjae28666
关注
高级IO之epoll模型
qq_68926231的博客
01-28 1295
日拱一卒，功不唐捐！一起进步~
epoll原理详解及epoll反应堆模型
LiuenshengUp的博客
11-12 1123
设想一个场景：有100万用户同时与一个进程保持着TCP连接，而每一时刻只有几十个或几百个TCP连接是活跃的(接收TCP包)，也就是说在每一时刻进程只需要处理这100万连接中的一小部分连接。那么，如何才能高效的处理这种场景呢？进程是否在每次询问操作系统收集有事件发生的TCP连接时，把这100万个连接告诉操作系统，然后由操作系统找出其中有事件发生的几百个连接呢？实际上，在Linux2.4版本以前，那时...
Linux 高级IO（四）多路转接之epoll，epoll 模型及原理
最新发布
2401_88465894的博客
05-31 686
本文深入解析了Linux的epoll机制，包括其核心原理和系统调用实现。epoll通过红黑树管理监听文件描述符，使用就绪队列高效返回事件，并借助内核回调机制实现事件主动通知。相比select/poll，epoll具有O(1)时间复杂度、无需重复注册等优势。文章详细介绍了epoll_create、epoll_ctl和epoll_wait三个系统调用的工作原理，剖析了内核中的eventpoll和epitem数据结构，以及它们如何通过文件描述符体系与用户空间交互。最后指出epoll特别适合高并发场景，但需要根据业
EPOLL模型详解
luseysd的博客
10-28 1656
参考自： http://blog.chinaunix.net/uid/28541347/cid-191916-list-4.html 一 epoll综述 1 selected 缺陷 首先，在Linux内核中，select所用到的FD_SET是有限的，即内核中有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，在我用的2.6.15-25-386内核中，该值是1024，搜索内核源代码得到： include/linux/posix_types.h: #define __FD_SETSIZE
epoll模型
MyHome
06-29 1182
poll模型 poll采用一个描述符事件结构的方式对描述符所关心的事件进行监控； 1.所关心的描述符 2.描述符所关心的事件 POLLIN （可读） | POLLOUT（可写） 3.描述符实际监控时就绪的事件 定义事件结构数组，将用户所关心...
Redis原理篇：网络模型剖析
2301_79949064的博客
02-25 969
文章摘要：本文详细介绍了Linux网络IO模型及其演进过程，包括阻塞IO、非阻塞IO、IO多路复用（select/poll/epoll）、信号驱动IO和异步IO等五种模型，重点分析了epoll机制的优势和工作原理。随后探讨了Redis的网络模型，指出其核心处理采用单线程设计的原因在于避免多线程带来的性能损耗和安全问题，同时揭示了Redis在不同版本中引入多线程的演进过程。文章通过对比各种IO模型的性能特点，阐明了epoll作为高效IO多路复用机制的技术优势，以及Redis选择单线程架构的设计考量。（149字
【Redis】原理-网络模型
qq_39166045的博客
01-05 1011
本文介绍了Linux I/O模型的基础知识，重点分析了用户空间与内核空间的区别以及四种I/O模型的工作原理。主要内容包括：1）用户空间和内核空间的划分及权限差异；2）I/O读写过程中缓冲区的使用；3）详细讲解阻塞I/O、非阻塞I/O、I/O多路复用三种模型的工作流程；4）深入分析select、poll、epoll三种多路复用实现方式的优缺点；5）特别说明epoll的水平触发和边缘触发两种模式的区别。文章通过图示和代码示例，系统性地阐述了Linux系统中I/O操作的核心机制，为理解高性能网络编程提供了理论基础
【操作系统】I/O多路复用网络模型
HeavenDan的博客
04-05 410
一、I/O多路复用简介 定义：指内核一旦发现进程指定一个或多个IO条件准备读取，就通知该进程。 适用场合： 1、当客户处理多个描述符时（一般是交互式输入和网络套接口），必须使用IO复用； 2、当一个客户同时处理多个套接口时，可能但很少出现； 3、TCP服务器纪要处理监听套接口，又要处理已连接套接口； 4、一个服务器既要处理TCP，又要处理UDP； 5、一个服务器要处理多个服务或多个协议。 I/O多路复用 VS 多进程/多线程：IO多路复用技术最大优势是系统开销小，系统不必创建进程/线程，也不必维护，大大减
14 Redis的IO多路复用模型
weixin_43338519的博客
08-09 233
Redis是跑在单线程的，所有的操作都是按顺序线性执行的，由于读写操作需要等待用户输入或者输出是阻塞的，所以某一个文件I/O阻塞会导致整个进程无法对其他客户提供服务，I/O多路复用就是为了解决这个问题而出现的。 阻塞I/O 当对某个文件描述符进行读写时，如果当前文件描述符不可读或者不可写，那么线程就会阻塞在那里，无法对其他操作做出相应。导致整个服务不可用。所以在需要处理多个客户端任务时，往往不会用阻塞模型。 在I/O多路复用模型中，有几个很重要的函数，比如select、poll、epoll，这些函数能够同时
2026.3.13 Redis的网络模型
jgyzl的博客
03-13 873
摘要 本文深入分析了Redis的网络IO模型，重点介绍了五种IO模型的工作原理和特点： 阻塞IO：用户进程在两个阶段都需阻塞等待，性能较差 非阻塞IO：第一阶段非阻塞但CPU空转，第二阶段仍阻塞 IO多路复用：核心解决方案，包括select/poll/epoll三种实现 信号驱动IO：通过信号通知就绪状态 异步IO：两个阶段都由内核完成 特别详细对比了select、poll和epoll三种多路复用技术的差异，指出epoll通过红黑树和就绪列表解决了前两者的性能瓶颈问题。文章还分析了LT和ET两种事件通知模式
【linux网络编程】- 开篇
记录博客，欢迎大家一起互动讨论
10-01 414
【linux网络编程】- 开篇
Netty权威指南-笔记1-IO模型
gs_jy的博客
06-01 357
I/O基础I/O网络模型简介阻塞I/O模型非阻塞I/O模型I/O复用模型信号驱动I/O模型异步I/O模型 I/O网络模型简介 根据I/O模型的分类，一共提供了5中I/O模型，分别是1.阻塞I/O模型；2.非阻塞I/O模型；3.I/O复用模型；4.信号驱动I/O模型;5.异步I/O模型。 阻塞I/O模型 由用户进程调用recvform指令到内核空间，请求数据。在此期间，进程阻塞，等待内核返回数据包或者内核空间返回错误后，进程任务才会结束。 非阻塞I/O模型 由用户进程调用recvform到内核，如果内核无准备
Linux 网络I/O模型
个人技术博客
04-14 627
Linux下面一共有五种可以使用的I/O模型，如下：1）阻塞式I/O2）非阻塞式I/O3）I/O多路复用（select与epoll）4）信号驱动式I/O5）异步I/O下面重点介绍前三种I/O模型。
Reactor与Rroactor网络模型
xiaofeilongyu的博客
03-27 529
Reactor与Proactor网络模型
epoll和select原理图解，如何选型高并发网络模型
2509_93883384的博客
12-24 188
理解 epoll 和 select 的原理，关键在于把握它们如何高效地管理大量网络连接。这两种机制都是 Linux 下实现 I/O 多路复用的核心工具
C#网络编程(六)----Socket编程模型
weixin_34246598的博客
06-30 85
Socket（套接字）是计算机网络中的一套编程接口，是网络编程的核心，它将复杂的网络协议封装为简单的API，是应用层(HTTP)与传输层(TCP)之间的桥梁。应用程序通过调用Socket API，比如connect、send、recv，无需处理IP包封装，路由选择等复杂网络操作，屏蔽底层细节将网络通信简化为建立连接-数据接收-数据发送-连接断开，降低了开发复杂度。
服务器端开发技术
weixin_33854644的博客
03-07 93
1. 多进程或多线程模型 多进程服务器：Apache，Nginx，lighttpd等服务器均为多进程模型，分为Master进程和Woker进程 多进程的优点：更强的容错性 - 一个进程挂掉不会导致整个系统崩溃，更好的多核可伸缩性 - 进程的使用将许多内核资源（如地址空间，页表，打开的文件）隔离，在多核系统上的可伸缩性强于多线程程序。 多线程服务器：Tomcat，Netty等服务器均为多线程模...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值