关于epoll水平触发的小问题

fuyuande

根据相关的资料得知，当epoll监听的对象设置为水平触发时(默认是水平触发)，当发生可读事件并且没有将数据读取完毕，epoll会多次触发，直到数据读完，这一点在测试的监听标准输入的时候得到验证。代码如下：

1. #include <sys/epoll.h>
   
2. #include <sys/types.h>
   
3. #include <sys/errno.h>
   
4. #include <stdlib.h>
   
5. #include <unistd.h>
   
6. #include <string.h>
   
7. #include <stdio.h>
   
8. 
   
9. #define BUFFER_SIZE 512
   
10. #define log(fmt, arg...) printf(""fmt, ##arg)
    
11. 
    
12. void main(){
    
13.     int efd, fds, i, fd;
    
14.     int ret;
    
15.     struct epoll_event g_event;             // epoll事件
    
16.     struct epoll_event *epoll_events_ptr;
    
17.     char buffer[BUFFER_SIZE] = {0};
    
18. 
    
19.     efd = epoll_create1(0);                 //创建epoll实例
    
20.     if (efd == -1) {
    
21.         log("create epoll fail \r\n");
    
22.         goto err;
    
23. 
    
24.     }
    
25.     log("create epoll instance success \r\n");
    
26.    
    
27.     epoll_events_ptr = (struct epoll_event *)calloc(2, sizeof(struct epoll_event));
    
28.     if (epoll_events_ptr == NULL) {
    
29.         log("calloc fail \r\n");
    
30.         goto err;
    
31.     }
    
32. 
    
33. 
    
34.     g_event.data.fd = STDIN_FILENO; //监听标准输入
    
35.     g_event.events = EPOLLIN;                               //默认水平触发
    
36.     epoll_ctl(efd, EPOLL_CTL_ADD, STDIN_FILENO, &g_event);         
    
37. 
    
38.     while(1) {                                              //监听epoll事件
    
39.         fds = epoll_wait(efd, epoll_events_ptr, 2, -1);
    
40.         for (i = 0; i<fds; i++)
    
41.         {   
    
42.             if (epoll_events_ptr[i].events & EPOLLIN)
    
43.             {   
    
44.                 ret = read(STDIN_FILENO, buffer, 1);
    
45.                 if(ret != -1)
    
46.                     log("recv msg : %s \n", buffer);
    
47.             }     
    
48.             memset(buffer, 0, BUFFER_SIZE);
    
49.         }        
    
50.     }   
    
51. 
    
52.    
    
53. err:
    
54.     if(epoll_events_ptr)
    
55.         free(epoll_events_ptr);
    
56. 
    
57.     return ;
    
58. 
    
59. }
    
60. 
    
61. 
    

复制代码

但是测试监听udp套接字的时候，当向套接字发送多个数据，每次只读取一个，epoll只触发了一次，同样是水平触发，不清楚为什么udp套接字没有多次触发，代码：

1. #include <netinet/in.h>
   
2. #include <sys/socket.h>
   
3. #include <sys/epoll.h>
   
4. #include <sys/types.h>
   
5. #include <arpa/inet.h>
   
6. #include <sys/errno.h>
   
7. #include <stdint.h>
   
8. #include <stdlib.h>
   
9. #include <string.h>
   
10. #include <stdio.h>
    
11. 
    
12. #define BUFFER_SIZE 512
    
13. #define log(fmt, arg...) printf(""fmt, ##arg)
    
14. 
    
15. void main(){
    
16.     int fd1,efd, fds, i, fd;
    
17.     int ret, addr_len;
    
18.     struct epoll_event g_event;             // epoll事件
    
19.     struct epoll_event *epoll_events_ptr;
    
20.     char buffer[BUFFER_SIZE] = {0};
    
21.     struct sockaddr_in addr1;
    
22. 
    
23.     fd1 = socket(AF_INET, SOCK_DGRAM, 0);   //创建套接字
    
24.     if (fd1 == -1) {
    
25.         log("create socket fail \r\n");
    
26.         return ;
    
27.     }     
    
28. 
    
29.     addr1.sin_family = AF_INET;             //设置本地地址与端口
    
30.     addr1.sin_addr.s_addr = INADDR_ANY;
    
31.     addr1.sin_port = htons(3500);   
    
32.     addr_len = sizeof(struct sockaddr_in);
    
33.    
    
34.     if (0 != bind(fd1, (struct sockaddr *)&addr1, sizeof(struct sockaddr_in))) {
    
35.         log("bind local listening addr fail，errno : %d \r\n", errno);
    
36.         goto err;
    
37.     }
    
38. 
    
39. 
    
40.     efd = epoll_create1(0);                 //创建epoll实例
    
41.     if (efd == -1) {
    
42.         log("create epoll fail \r\n");
    
43.         goto err;
    
44. 
    
45.     }
    
46.     log("create epoll instance success \r\n");
    
47.    
    
48.     epoll_events_ptr = (struct epoll_event *)calloc(2, sizeof(struct epoll_event));
    
49.     if (epoll_events_ptr == NULL) {
    
50.         log("calloc fail \r\n");
    
51.         goto err;
    
52.     }
    
53. 
    
54. 
    
55.     g_event.data.fd = fd1;
    
56.     g_event.events = EPOLLIN | EPOLLET;   //水平触发
    
57.     epoll_ctl(efd, EPOLL_CTL_ADD, fd1, &g_event);         
    
58. 
    
59.     while(1) {
    
60.         fds = epoll_wait(efd, epoll_events_ptr, 2, -1); //阻塞
    
61.         for (i = 0; i<fds; i++)
    
62.         {   
    
63.             if (epoll_events_ptr[i].events & EPOLLIN)
    
64.             {   
    
65.                 ret = read(fd1, buffer, 1);
    
66.                 if(ret != -1)
    
67.                     log("recv msg : %s \n", buffer);
    
68.                 }     
    
69.             memset(buffer, 0, BUFFER_SIZE);
    
70.         }        
    
71.     }   
    
72. 
    
73.    
    
74. err:
    
75.     close(fd1);
    
76.     if(epoll_events_ptr)
    
77.         free(epoll_events_ptr);
    
78. 
    
79.     return ;
    
80. 
    
81. }
    
82. 
    

复制代码

当向套接字发送3个字节的时候，只读取一个，按道理说epoll应该触发三次，可是这里只触发了一次。
有熟悉的大佬讲一下

fuyuande

问题原因清楚了。在stackoverflow上提问，有人回答说是因为UDP套接字如果一次没有读完，剩余数据会被丢弃，所以epoll只触发了一次。UDP套接字和面向字节流的TCP不同，它是以报文为单位的。实际测试了一下也验证了该结论。果然对套接字了解不够多啊。相关链接如下：stackoverflow