在Linux环境下select函数的初体验

select介绍

在linux中, 主要的 IO复用方式中, 有epoll, poll 和select, 这次先来学习下select.

select 能够同时监视多个文件描述符的变法, 也支持超时返回.

先来看下select函数的定义


  1. /* /usr/include/sys/select.h */ 
  2. extern int select (int __nfds,               // 最大文件描述符+1 
  3.            fd_set *__restrict __readfds,     // 读状态文件集 
  4.            fd_set *__restrict __writefds,    // 写状态文件集 
  5.            fd_set *__restrict __exceptfds,   // 异常状态文件集 
  6.            struct timeval *__restrict __timeout);  // 超时时间  

如上图函数声明所示, 不管我们关注什么状态, 我们都应该把同一类状态的文件描述符存到同一个fd_set集合,以便select能够相应的位置打上标签, 以便后续我们来判断该文件描述符是否已经准备好

这些传递给select函数的参数, 将告诉内核:

  • 我们需要监听的文件描述符
  • 对于每个文件描述符, 我们所关心的状态 (读/写/异常)
  • 我们要等待多长时间 (无限长/超时返回)

而内核也会通过select的返回, 告知我们一些信息:

  • 已经准备好的文件描述符个数
  • 那三种状态分别是哪些文件描述符

我们可以通过以下方式将关注的文件描述符加入相应的文件集:


  1. int socket_test; 
  2. socket_test = socket(...);      //创建socket文件描述符 
  3. connent(socket_test,..);        //连接服务端 
  4. FD_SET(socket_test, &rdfds);    //加入读状态文件集 
  5. FD_SET(socket_test, &wdfds);    //加入写状态文件集 
  6. ....  

select原理

select函数执行顺序是: SYSCALL_DEFINE5 (sys_select) -> core_sys_select -> do_select

我们都知道, select 支持监听三个文件集: 读文件集, 写文件集, 异常文件集;

在我们调用FD_SET(socket_test, &rdfds)时, 实际上执行的操作是: 在rdfds成员数组中, 将__FDELT (d)位置的值 设成 __FDMASK (d), 直接说会有点疑惑, 先看下相关的函数,宏定义是怎样定义的吧:


  1. /* 取自: /usr/include/sys/select.h */ 
  2. #define FD_SET(fd, fdsetp)  __FD_SET (fd, fdsetp) 
  3. typedef long int __fd_mask; 
  4.  
  5. /* 取自: /usr/include/bits/select.h  */ 
  6.  
  7. #define __NFDBITS   (8 * (int) sizeof (__fd_mask)) 
  8. #define __FDELT(d)  ((d) / __NFDBITS) 
  9. #define __FDMASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS)) 
  10.  
  11. #define __FD_SET(d, set)    (__FDS_BITS (set)[__FDELT (d)] |= __FDMASK (d)) 
  12.  
  13. typedef struct 
  14.   { 
  15.     /* XPG4.2 requires this member name.  Otherwise avoid the name 
  16.        from the global namespace.  */ 
  17. #ifdef __USE_XOPEN 
  18.     __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS]; 
  19. # define __FDS_BITS(set) ((set)->fds_bits) 
  20. #else 
  21.     __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS]; 
  22. # define __FDS_BITS(set) ((set)->__fds_bits) 
  23. #endif 
  24.   } fd_set; 
  25.  
  26. /* /usr/include/linux/posix_types.h */ 
  27. #define __FD_SETSIZE    1024  

举个栗子, 假设 fd=3, 当我们执行FD_SET(fd, &rdfds)时:

  1. 算出 __FDELT(d) 和 __FDMASK(d)的值, 通过上面的宏定义, 可以分别得出结果: 3/(8*8), 1<<3%(8*8), 也就是0 和 二进制的 0000 0100
  2. 然后分别将值存入 rdfds.__fds_bits第0个位置, 值为十进制的8
  3. 我们可以将__fds_bit的每个索引看成是一个聚合的过程, 每个值8字节, 也就是有64位, 可以存64个fd, 在我的系统上, 算出数组的长度是__FD_SETSIZE / __NFDBITS = 1024/8=128个, 也就是大概能容纳 128*64=8192(如果理解错误请指出)

经过上面的运算, 我们将需要关注的文件描述关联到 rdfds文件集了, 对于写文件集, 异常文件集都是同样的运算, 等这些步骤都进行完了, 接下来就是进入core_sys_select函数了:

  1. 执行到 core_sys_select 时, 定义一个fd_set_bits结构体: fds.
  2. 分别为fds的成员(in, out, ex, res_in, res_out, res_ex)申请内存
  3. 将我们传给select的 rdfds, wrfds, exfds分别赋值给 in, out, ex, 这样fds就能记录三个集合的结果了
  4. 初始化那个三个成员之后, 将执行do_select(n, &fds, end_time)
  5. 在do_select中, 函数将进入死循环,其中还有两个循环, 分别是针对 "最大文件描述符数" 和 fd_set_bits数组中单个值位数. 从上面我们已经知道, 在fd_set_bits每个值都代表所关注的文件描述符, 每个值是__NFDBITS(8 *8字节)大小,也就是64位, 所以在上面循环内, 还要再循环64次
  6. 看到这里其实大家都应该有个底了, 为什么要循环那么多次, 因为我们需要通过每个文件描述符对应的file_operations结构体的接口f_op->poll来得知是否已经准备好了

简单介绍 file_operations

我们都知道,当我们打开一些设备或者文件时, 总是返回一个文件描述符, 其实通过这个文件描述符, 我们通过fget_light 来获得对应的file结构体, 为什么还要反查这个file, 因为通过这个file结构体可以得到: file_operations结构体

file_operations结构体: 用来存储驱动内核模块提供的对 设备进行各种操作的函数的指针。该结构体的每个域都对应着驱动内核模块用来处理某个被请求的 事务的函数的地址。


  1. /* linux-2.6.32/include/linux/fs.h */ 
  2. struct file_operations { 
  3.    ... 
  4.     unsigned int (*poll) (struct file *, struct poll_table_struct *);    // select通过这个来获取状态 
  5.    ...(其他接口忽略)  

do_select 循环体源码:


  1. /* select.c/do_select() */ 
  2. for (;;) { 
  3.         unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp; 
  4.  
  5.         inp = fds->in; outp = fds->out; exp = fds->ex; 
  6.         rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex; 
  7.  
  8.         for (i = 0; i < n; ++rinp, ++routp, ++rexp) {       
  9.             unsigned long in, out, ex, all_bits, bit = 1, mask, j; 
  10.             unsigned long res_in = 0, res_out = 0, res_ex = 0; 
  11.             const struct file_operations *f_op = NULL; 
  12.             struct file *file = NULL; 
  13.  
  14.             in = *inp++; out = *outp++; ex = *exp++; 
  15.             all_bits = in | out | ex; 
  16.             if (all_bits == 0) { 
  17.                 i += __NFDBITS; 
  18.                 continue; 
  19.             } 
  20.  
  21.             for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {   // 遍历64位 
  22.                 int fput_needed; 
  23.                 if (i >= n) 
  24.                     break; 
  25.                 if (!(bit & all_bits)) 
  26.                     continue; 
  27.  
  28.                 //在当前进程的struct files_struct中根据所谓的用户空间文件描述符fd来获取文件描述符 
  29.                 file = fget_light(i, &fput_needed);             
  30.                 if (file) { 
  31.                     f_op = file->f_op;          // file_operations结构体 
  32.                     mask = DEFAULT_POLLMASK; 
  33.                     if (f_op && f_op->poll) { 
  34.                         wait_key_set(wait, in, out, bit); 
  35.                         mask = (*f_op->poll)(file, wait); 
  36.                     } 
  37.                     fput_light(file, fput_needed); 
  38.                     if ((mask & POLLIN_SET) && (in & bit)) {    //判断读状态 
  39.                         res_in |= bit; 
  40.                         retval++; 
  41.                         wait = NULL; 
  42.                     } 
  43.                     if ((mask & POLLOUT_SET) && (out & bit)) {  //判断写状态 
  44.                         res_out |= bit; 
  45.                         retval++; 
  46.                         wait = NULL; 
  47.                     } 
  48.                     if ((mask & POLLEX_SET) && (ex & bit)) {    //判断异常状态 
  49.                         res_ex |= bit; 
  50.                         retval++; 
  51.                         wait = NULL; 
  52.                     } 
  53.                 } 
  54.             } 
  55.             if (res_in) 
  56.                 *rinp = res_in; 
  57.             if (res_out) 
  58.                 *routp = res_out; 
  59.             if (res_ex) 
  60.                 *rexp = res_ex; 
  61.             cond_resched(); 
  62.         } 
  63.         wait = NULL; 
  64.         if (retval || timed_out || signal_pending(current)) 
  65.             break; 
  66.         if (table.error) { 
  67.             retval = table.error; 
  68.             break; 
  69.         } 
  70.  
  71.         /* 
  72.          * If this is the first loop and we have a timeout 
  73.          * given, then we convert to ktime_t and set the to 
  74.          * pointer to the expiry value. 
  75.          */ 
  76.         if (end_time && !to) { 
  77.             expire = timespec_to_ktime(*end_time); 
  78.             to = &expire; 
  79.         } 
  80.  
  81.         if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE, 
  82.                        to, slack)) 
  83.             timed_out = 1; 
  84.     }  

当select经历完上面的流程, 将会有以下结果:

  • >0: 准备好的文件描述符个数
  • 0: 超时
  • -1: 出错或者接收到信号

那我们接下来要做的就是,

  • 通过行FD_ISSET()判断之前绑定的文件fd, 如果为真, 则进行相应操作
  • 因为select返回后, 之前存好的rdfds, wdfds, exfds都会被清空, 所以需要用FD_SET()重新加入

select实战

上面已经学习到关于select的相关知识, 那么我们应该要来实战下:

这次我们需要实现的目标是:

一个程序, 同时连接3个socket_server, 并且将socket_server发送的消息打印出来(不需要响应, 也不需要交互)

程序代码:


  1. /* filename: test_select.c */ 
  2.  
  3. #include <stdio.h> 
  4. #include <stdlib.h> 
  5. #include <sys/socket.h> 
  6. #include <sys/select.h> 
  7. #include <sys/types.h> 
  8. #include <netinet/in.h> 
  9. #include <unistd.h> 
  10. #include <fcntl.h> 
  11. void main() 
  12.     // socket1 
  13.     int socketd; 
  14.     char buffer[1025];  
  15.     struct sockaddr_in seraddr; 
  16.     socketd = socket(AF_INET, SOCK_STREAM, 0); 
  17.     seraddr.sin_family = AF_INET; 
  18.     seraddr.sin_port = htons(9997); 
  19.     inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr); 
  20.     if (connect(socketd, (struct sockaddr *) &seraddr, sizeof(seraddr))<0) 
  21.     { 
  22.         printf("socketd1 connect failed\n"); 
  23.         exit(3); 
  24.     } 
  25.  
  26.     // socket2 
  27.     int socketd2; 
  28.     char buffer2[1025]; 
  29.     struct sockaddr_in seraddr2; 
  30.     socketd2 = socket(AF_INET, SOCK_STREAM, 0); 
  31.     seraddr2.sin_family = AF_INET; 
  32.     seraddr2.sin_port = htons(9998); 
  33.     inet_pton(AF_INET, "127.0.0.1", &seraddr2.sin_addr); 
  34.     if (connect(socketd2, (struct sockaddr *) &seraddr2, sizeof(seraddr))<0) 
  35.     { 
  36.         printf("socketd2 connect failed\n"); 
  37.         exit(3); 
  38.     } 
  39.  
  40.     // scoket3 
  41.     int socketd3; 
  42.     char buffer3[1025]; 
  43.     struct sockaddr_in seraddr3; 
  44.     socketd3 = socket(AF_INET, SOCK_STREAM, 0); 
  45.     seraddr3.sin_family = AF_INET; 
  46.     seraddr3.sin_port = htons(9999); 
  47.     inet_pton(AF_INET, "127.0.0.1", &seraddr3.sin_addr); 
  48.     if (connect(socketd3, (struct sockaddr *) &seraddr3, sizeof(seraddr))<0) 
  49.     { 
  50.         printf("socketd3 connect failed\n"); 
  51.         exit(3); 
  52.     } 
  53.  
  54.     int maxfdp;   
  55.     fd_set fds;                      // select需要的文件描述符集合  
  56.     maxfdp = socketd3 + 1;           // select 第一个形参就是打开的最大文件描述符+1 
  57.     struct timeval timeout = {3, 0}; // 超时设置 
  58.     while(1) 
  59.     { 
  60.         FD_ZERO(&fds);               // 初始化文件描述符集合 
  61.         FD_SET(socketd, &fds);       // 分别添加以上三个需要监听的文件描述符 
  62.         FD_SET(socketd2, &fds); 
  63.         FD_SET(socketd3, &fds); 
  64.         select(maxfdp, &fds, NULL, NULL, &timeout); 
  65.         // 通过FD_ISSET 来分别判断 监听的文件描述符在fds有没有被设置成1 
  66.         if (FD_ISSET(socketd, &fds)) 
  67.         { 
  68.             read(socketd, buffer, 1024); 
  69.             printf("1 %s\n",buffer); 
  70.         } 
  71.         if(FD_ISSET(socketd2, &fds)) 
  72.         { 
  73.             read(socketd2, buffer2, 1024); 
  74.             printf("2 %s\n",buffer2); 
  75.              
  76.         } 
  77.         if(FD_ISSET(socketd3, &fds)) 
  78.         { 
  79.             read(socketd3, buffer3, 1024); 
  80.             printf("3 %s\n",buffer3); 
  81.              
  82.         } 
  83.     } 
  84. }  

为了快速建立简单的测试服务端, 所以用python实现简单socket_server:


  1. # socket1.py 
  2.  
  3. import socket 
  4. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
  5. s.bind(('localhost', 9997)) 
  6. s.listen(2) 
  7. rint 'Socket1 is on ready!' 
  8. client, info = s.accept() 
  9. print info 
  10. while 1: 
  11.     message = raw_input('input: ') 
  12.     client.send(message) 
  13. s.close() 
  14.  
  15. ------------------------------- 
  16. # socket2.py 
  17.  
  18. import socket 
  19. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
  20. s.bind(('localhost', 9998)) 
  21. s.listen(2) 
  22. rint 'Socket2 is on ready!' 
  23. client, info = s.accept() 
  24. print info 
  25. while 1: 
  26.     message = raw_input('input: ') 
  27.     client.send(message) 
  28. s.close() 
  29.  
  30. ------------------------------- 
  31. # socket3.py 
  32.  
  33. import socket 
  34. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
  35. s.bind(('localhost', 9999)) 
  36. s.listen(2) 
  37. rint 'Socket3 is on ready!' 
  38. client, info = s.accept() 
  39. print info 
  40. while 1: 
  41.     message = raw_input('input: ') 
  42.     client.send(message) 
  43. s.close()  

分别运行 socket1.py, socket2.py, socket3.py将会看到如下结果:


  1. # 运行 socket1.py 
  2. [root@iZ23pynfq19Z ~]# python socket1.py  
  3. Socket1 is on ready! 
  4.  
  5. ---------------------- 
  6. # 运行 socket1.py 
  7. [root@iZ23pynfq19Z ~]# python socket2.py  
  8. Socket2 is on ready! 
  9.  
  10. ---------------------- 
  11. # 运行 socket1.py 
  12. [root@iZ23pynfq19Z ~]# python socket3.py  
  13. Socket3 is on ready!  

当我们编译 test_select.c 并运行时, 将会看到三个服务端都出现了相应的响应:


  1. # 运行 socket1.py 
  2. [root@iZ23pynfq19Z ~]# python socket1.py  
  3. Socket1 is on ready! 
  4. ('127.0.0.1', 55951)  # 客户端连接的信息, 端口不一定相同 
  5. input: 
  6.  
  7. ---------------------- 
  8. # 运行 socket1.py 
  9. [root@iZ23pynfq19Z ~]# python socket2.py  
  10. Socket2 is on ready! 
  11. ('127.0.0.1', 55921) 
  12. input: 
  13.  
  14. ---------------------- 
  15. # 运行 socket1.py 
  16. [root@iZ23pynfq19Z ~]# python socket3.py  
  17. Socket3 is on ready! 
  18. ('127.0.0.1', 55933) 
  19. input:  

那么我们来尝试三个服务端分别发送消息到select程序吧:


  1. # socket1.py 
  2. [root@iZ23pynfq19Z ~]# python socket1.py  
  3. Socket1 is on ready! 
  4. ('127.0.0.1', 55951)  # 客户端连接的信息, 端口不一定相同 
  5. input: asd 
  6. input: qwe 
  7. input: as 
  8. input:  
  9. ---------------------- 
  10. # socket1.py 
  11. [root@iZ23pynfq19Z ~]# python socket2.py  
  12. Socket2 is on ready! 
  13. ('127.0.0.1', 55921) 
  14. input: asd 
  15. input: asd 
  16. input: asd 
  17. input: as 
  18. input: s 
  19. input:  
  20.  
  21. ---------------------- 
  22. # socket1.py 
  23. [root@iZ23pynfq19Z ~]# python socket3.py  
  24. Socket3 is on ready! 
  25. ('127.0.0.1', 55933) 
  26. input: asd 
  27. input: qwe 
  28. input: a 
  29. input:   

将看到select程序都能输出三个socket_server发出的消息:

需要注意的是:

  • 前面的数字是socket_server的编号, 因为server发送消息的顺序是乱的, 所以输出的编号也是乱的
  • 这次只为验证select, 所以并没对程序的健壮性作较好的设计, 所以如果服务端/客户端刷屏了, 直接ctrl-c终止吧

经过上述的实验, 我们应该能够简单的了解select的用法和效果, 通过select实现IO多路复用, 可以让我们一定程度上避免多线程/多进程的繁琐, 在我们日常工作上, 有必要的话尝试这种方式也不失一种偷懒的方法.

作者:Lin_R

来源:51CTO

时间: 2024-11-01 17:23:22

在Linux环境下select函数的初体验的相关文章

Linux下select函数的使用

一.Select 函数详细介绍     Select在Socket编程中还是比较重要的,可是对于初学Socket的人来说都不太爱用Select写程序,他们只是习惯写诸如connect. accept.recv或recvfrom这样的阻塞程序(所谓阻塞方式block,顾名思义,就是进程或是线程执行到这些函数时必须等待某个事件的发 生,如果事件没有发生,进程或线程就被阻塞,函数不能立即返回).     可是使用Select就可以完成非阻塞(所谓非阻塞方式non-block,就是进程或线程执行此函数时

linux c语言 select函数用法

linux c语言 select函数用法 表头文件 #i nclude<sys/time.h> #i nclude<sys/types.h> #i nclude<unistd.h> 定义函数 int select(int n,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout); 函数说明 select()用来等待文件描述词状态的改变.参数n代表最大的文件描述词加1

PHP 命令行模式实战之cli+mysql 模拟队列批量发送邮件(在Linux环境下PHP 异步执行脚本发送事件通知消息实际案例)

源码地址:https://github.com/Tinywan/PHP_Experience 测试环境配置: 环境:Windows 7系统 .PHP7.0.Apache服务器 PHP框架:ThinkPHP框架(3.2) Redis数据库:测试数据回调函数:通过一个Redis的自增incr来测试异步脚本执行的次数和访问的时间(平时都是用Redis测试写日志的) 编辑器:Visual Studio Code (CLI运行环境好看点) PHP 的命令行模式       从版本 4.3.0 开始,PHP

【转】linux环境下的c++编程

linux环境下的c++编程        就C++开发工具而言,与Windows下微软(VC, VS2005等)一统天下相比,Linux/Unix下C++开发,可谓五花八门,各式各样.Emacs, vi, eclipse, anjuta,kdevelop等层出不穷.         Windows下,开发工具多以集成开发环境IDE的形式展现给最终用户.例如,VS2005集成了编辑器,宏汇编ml,C /C++编译器cl,资源编译器rc,调试器,文档生成工具, nmake.它们以集成方式提供给最终

Linux环境下进程中断的原因

问题描述 Linux环境下进程中断的原因 linux环境下,哪些原因可能造成某进程中断?或者说,代码中哪些不合理的地方可能会引起进程的中断? 解决方案 内存溢出等,程序无法处理的异常都会造成程序进程中断 解决方案二: 中断是一种是一种机制: 看下面的一段汇编代码: .section .data string:.ascii "hello" .section .text .globl _start _start: movl $4,%eax#sys_call_num movl $2,%ebx

file-c语言在linux环境下进行文件复制的代码,使用时出错,求各位大神帮忙解答下

问题描述 c语言在linux环境下进行文件复制的代码,使用时出错,求各位大神帮忙解答下 #include#include#include#include#include#include#include#define BUFSIZE 4096#define COPYMODE 0644 void oops(char *char *);void *emalloc(size_t);void do_copy(char *char *);void copydir(char *char *);int isdi

fork函数调用 linux环境下

问题描述 fork函数调用 linux环境下 linux环境下1秒内如何让父进程执行printf函数5次 子进程执行printf10次 解决方案 你fork两个子进程可以控制倍数.不过你要想控制1s内的次数,这个比较难,取决于CPU指令的时间,进程调度等

Linux环境下安装解压缩版MySQL5.5

Linux环境下安装解压缩版MySQL5.5成功完成. 本来是想在www.mysql.com网上下载安装的mysql的,看了几个版本全是解压的.就在网上搜索了一些资料进行了解压版的安装. 下面给大家说一下设置的过程. 首先参考了:http://sheng.iteye.com/blog/830209 的博客.   (由于没有安装成功,所以在其博客的基础上做了相应的修改如下) 1.下载MySQL免安装版/二进制版软件(不用编译)     按照自己系统选择 http://www.mysql.com/d

Linux环境下段错误的产生原因及调试方法小结

最近在Linux环境下做C语言项目,由于是在一个原有项目基础之上进行二次开发,而且项目工程庞大复杂,出现了不少问题,其中遇到最多.花费时间最长的问题就是著名的"段错误"(Segmentation Fault).借此机会系统学习了一下,这里对Linux环境下的段错误做个小结,方便以后同类问题的排查与解决. 1. 段错误是什么 一句话来说,段错误是指访问的内存超出了系统给这个程序所设定的内存空间,例如访问了不存在的内存地址.访问了系统保护的内存地址.访问了只读的内存地址等等情况.这里贴一个