聊一聊 .NET在Linux下的IO多路复用select和epoll

一：背景

1. 讲故事

在windows平台上，相信很多人都知道.NET异步机制是借助了Windows自带的 IO完成端口 实现的异步交互，那在 Linux 下.NET 又是怎么玩的呢？主要还是传统的 select，poll，epoll 的IO多路复用，在 coreclr源代码中我们都能找到它们的影子。

• select & poll
  

在平台适配层的 pal.cpp 文件中，有这样的一句话。

1. #if HAVE_POLL
2. #include <poll.h>
3. #else
4. #include "pal/fakepoll.h"
5. #endif  // HAVE_POLL

复制代码

简而言之就是在不支持 poll 的linux版本中使用 select（fakepoll） 模拟，参考代码如下：

• epoll
  

同样的在 linux 中你也会发现很多，截图如下：

二：select IO多路复用

1. select 解读

在没有 select 之前，我们需要手工管理多句柄的收发，在使用select IO多路复用技术之后，这些多句柄管理就由用户转交给linux系统了，这个也可以从核心的 select 函数看出。

1. int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

复制代码

• readfds,writefds,exceptfds
  

这三个字段依次监视着哪些句柄已成可读状态，哪些句柄已成可写状态，哪些句柄已成异常状态，那技术上是如何实现的呢？在libc 中定义了一个 bit 数组，刚好文件句柄fd值作为 bit数组的索引，linux 在内核中只需要扫描 __fds_bits 中哪些位为1 即可找到需要监控的句柄。

1. /* fd_set for select and pselect.  */
2. typedef struct
3.   {
4.     /* XPG4.2 requires this member name.  Otherwise avoid the name
5.        from the global namespace.  */
6. #ifdef __USE_XOPEN
7.     __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS];
8. # define __FDS_BITS(set) ((set)->fds_bits)
9. #else
10.     __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
11. # define __FDS_BITS(set) ((set)->__fds_bits)
12. #endif
13.   } fd_set;

复制代码

• nfds，timeout
  

为了减少扫描范围，提高程序性能，需要用户指定一个最大的扫描值到 nfds 上。后面的timeout即超时时间。
2. select 的一个小例子

说了再多还不如一个例子有说服力，我们使用 select 机制对 Console 控制台句柄 (STDIN_FILENO) 进行监控，一旦有数据进来立马输出，参考代码如下：

1. #include <stdio.h>
2. #include <sys/select.h>
3. #include <unistd.h>
5. int main()
6. {
7.     fd_set readfds;
8.     struct timeval timeout;
9.     char buf[256];
11.     printf("Enter text (press Ctrl+D to end):\n");
13.     while (1)
14.     {
15.         FD_ZERO(&readfds);
16.         FD_SET(STDIN_FILENO, &readfds);
17.         timeout.tv_sec = 5; // 5秒超时
18.         timeout.tv_usec = 0;
20.         int ready = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &timeout);
22.         if (ready == -1)
23.         {
24.             perror("select");
25.             break;
26.         }
27.         else if (ready == 0)
28.         {
29.             printf("\nTimeout (5秒无输入).\n");
30.             break;
31.         }
32.         else if (FD_ISSET(STDIN_FILENO, &readfds))
33.         {
34.             // 使用 fgets 逐行读取
35.             if (fgets(buf, sizeof(buf), stdin) != NULL)
36.             {
37.                 printf("You entered: %s", buf); // 输出整行（包含换行符）
38.             }
39.             else
40.             {
41.                 printf("\nEnd of input (Ctrl+D pressed).\n");
42.                 break;
43.             }
44.         }
45.     }
47.     return 0;
48. }

复制代码

稍微解释下代码逻辑。

1. /* Standard file descriptors.  */
2. #define        STDIN_FILENO        0        /* Standard input.  */
3. #define        STDOUT_FILENO        1        /* Standard output.  */
4. #define        STDERR_FILENO        2        /* Standard error output.  */

复制代码

• 将 STDIN_FILENO=0 塞入到可读句柄监控 (readfds) 中。
  
• 数据进来之后 select 被唤醒,执行后续逻辑。
  
• 通过 FD_ISSET 判断 bit=0 的位置(STDIN_FILENO)是否可用，可用的话读取数据。
  

如果大家对 select 底层代码感兴趣，可以看下 linux 的 do_select 简化实现，大量的遍历逻辑(bit)。

1. static noinline_for_stack int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time)
2. {
3.         for (;;) {
4.                 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
5.                 bool can_busy_loop = false;
7.                 inp = fds->in; outp = fds->out; exp = fds->ex;
8.                 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
10.                 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
11.                         in = *inp++; out = *outp++; ex = *exp++;
12.                         all_bits = in | out | ex;
14.                         for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {
15.                                 mask = select_poll_one(i, wait, in, out, bit,busy_flag);
16.                                 if ((mask & POLLIN_SET) && (in & bit)) {
17.                                         res_in |= bit;
18.                                         retval++;
19.                                         wait->_qproc = NULL;
20.                                 }
21.                                 if ((mask & POLLOUT_SET) && (out & bit)) {
22.                                         res_out |= bit;
23.                                         retval++;
24.                                         wait->_qproc = NULL;
25.                                 }
26.                                 if ((mask & POLLEX_SET) && (ex & bit)) {
27.                                         res_ex |= bit;
28.                                         retval++;
29.                                         wait->_qproc = NULL;
30.                                 }
31.                         }
32.                 }
34.                 if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE, to, slack))
35.                         timed_out = 1;
36.         }
38.         return retval;
39. }

复制代码

三：epoll IO多路复用

1. epoll 解读

现在主流的软件(Redis,Nigix) 都是采用 epoll，它解决了select低效的遍历，毕竟数组最多支持1024个bit位，一旦句柄过多会影响异步读取的效率。epoll的底层借助了。

• 红黑树：对句柄进行管理，复杂度为 O(logN)。
  
• 就绪队列：一旦句柄变得可读或可写，内核会直接将句柄送到就绪队列。
  

libc中使用 epoll_wait 函数监视着就绪队列，一旦有数据立即提取，复杂度 O(1)，其实这个机制和 Windows 的IO完成端口 已经很靠近了，最后配一下参考代码。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/epoll.h>
5. #include <fcntl.h>
6. #include <errno.h>
8. #define MAX_EVENTS 10   // 最大监听事件数
9. #define TIMEOUT_MS 5000 // epoll_wait 超时时间（毫秒）
11. int main()
12. {
13.     int epoll_fd, nfds;                        // epoll 文件描述符和返回的事件数
14.     struct epoll_event ev, events[MAX_EVENTS]; // epoll 事件结构体
15.     char buf[256];
17.     // 创建 epoll 实例
18.     epoll_fd = epoll_create1(0);
19.     if (epoll_fd == -1)
20.     {
21.         perror("epoll_create1");
22.         exit(EXIT_FAILURE);
23.     }
25.     // 配置并添加标准输入到 epoll 监听
26.     ev.events = EPOLLIN;       // 监听文件描述符的可读事件（输入）
27.     ev.data.fd = STDIN_FILENO; // 监听标准输入（文件描述符 0）
29.     if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) == -1)
30.     {
31.         perror("epoll_ctl: STDIN_FILENO");
32.         exit(EXIT_FAILURE);
33.     }
35.     printf("Enter text line by line (press Ctrl+D to end):\n");
37.     // 主循环：监听事件
38.     while (1)
39.     {
40.         // 等待事件发生或超时
41.         nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, TIMEOUT_MS);
43.         if (nfds == -1)
44.         {
45.             perror("epoll_wait");
46.             break;
47.         }
48.         else if (nfds == 0)
49.         {
50.             printf("\nTimeout (5秒无输入).\n");
51.             break;
52.         }
54.         // 处理所有触发的事件
55.         for (int n = 0; n < nfds; ++n)
56.         {
57.             if (events[n].data.fd == STDIN_FILENO)
58.             {
59.                 // 使用 fgets 逐行读取输入
60.                 if (fgets(buf, sizeof(buf), stdin) != NULL)
61.                 {
62.                     printf("You entered: %s", buf);
63.                 }
64.                 else
65.                 {
66.                     // 输入结束（用户按下 Ctrl+D）
67.                     printf("\nEnd of input (Ctrl+D pressed).\n");
68.                     break;
69.                 }
70.             }
71.         }
72.     }
74.     close(epoll_fd);
75.     return 0;
76. }

复制代码

四：总结

说了这么多，文尾总结下目前主流的 epoll 和 iocp 各自的特点。
特性epoll (Linux)IOCP (Windows)模型事件驱动 (Reactor)完成端口 (Proactor)核心思想通知可读写事件通知I/O操作完成适用场景高并发网络编程高并发I/O操作编程复杂度较低较高网络I/O性能极佳(百万级连接)优秀磁盘I/O支持有限完善CPU利用率高中内存开销低中

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！