Linux select学习笔记★★★★★

古城微笑少年丶 2022-06-12 09:14 152阅读 0赞

**Linux select学习笔记★★★★★** \[嵌入式\]

select系统调用是用来让我们的程序监视多个文件描述符(file descrīptor)的状态变化的。程序会停在select这里等待，直到被监视的文件描述符有某一个或多个发生了状态改变。select()的机制中提供一fd\_set的数据结构，实际上是一long类型的数组， 每一个数组元素都能与一打开的文件描述符（不管是Socket描述符,还是其他 文件或命名管道或设备描述符）建立联系，建立联系的工作由程序员完成， 当调用select()时，由内核根据IO状态修改fd\_set的内容，由此来通知执 行了select()的进程哪一Socket或文件可读，

select函数原型如下：  
int select(int nfds, fd\_set \*readfds, fd\_set \*writefds, fd\_set \*exceptfds, struct timeval \*timeout);

函数的最后一个参数timeout显然是一个超时时间值，其类型是struct timeval \*，即一个struct timeval结构的变量的指针，所以我们在程序里要申明一个struct timeval tv;然后把变量tv的地址&tv传递给select函数。struct timeval结构如下：

struct timeval \{  
long tv\_sec; /\* seconds \*/  
long tv\_usec; /\* microseconds \*/  
\};

第2、3、4三个参数的类型是一样的： fd\_set \*，即我们在程序里要申明几个fd\_set类型的变量，比如定义了rfds, wfds, efds。

另外关于fd\_set类型的变量，还有一组标准的宏定义来处理此类变量：

FD\_ZERO(fd\_set \*fdset)：清空fdset与所有文件描述符的联系。

FD\_SET(int fd, fd\_set \*fdset)：建立文件描述符fd与fdset的联系。

FD\_CLR(int fd, fd\_set \*fdset)：清除文件描述符fd与fdset的联系。

FD\_ISSET(int fd, fd\_set \*fdset)：检查fd\_set联系的文件描述符fd是否可读写，>0表示可读写。

（关于fd\_set及相关宏的定义见/usr/include/sys/types.h）定义的这三个参数都是描述符的集合，第一个rfds是用来保存这样的描述符的：当描述符的状态变成可读的时系统就会告诉select函数返回，第二个wfds是指有描述符状态变成可写的时系统就会告诉select函数返回，第三个参数efds是特殊情况，即描述符上有特殊情况发生时系统会告诉select函数返回。下面以一个输入为例来说明：

int fd1, fd2; /\*  在定义两个描述符\*/

fd1 = socket(...); /\*  创建socket连接\*/

fd2 = open(“/dev/tyS0”,O\_RDWR); /\* 打开一个串口\*/

FD\_ZERO(&rfds); /\*  用select函数之前先把集合清零 \*/

FD\_SET(fd1, &rfds); /\*  分别把2个描述符加入读监视集合里去 \*/

FD\_SET(fd2, &rfds);

int maxfd = 0;

maxfd = (fd1>fd2)?(fd1+1):(fd2+1); /\* 注意是最大值还要加1 \*/

ret = select(maxfd, &rfds, NULL, NULL, &tv); /\*然后调用select函数\*/

这样就可以使用一个开关语句（switch语句）来判断到底是哪一个输入源在输入数据。具体判断如下：

switch（ret）\{

case -1：perror("select");/\*这说明select函数出错 \*/

case 0：printf("超时\\n"); /\* 说明在设定的时间内，socket的状态没有发生变化 \*/

default：

if（FD\_ISSET(fd1, &rfds)）处理函数1（）；/\*socket有数据来\*/

if（FD\_ISSET(fd2, &rfds)）处理函数2（）；/\*ttyS0有数据来\*/

以下来自网络搜索：

Linux下select调用的过程:

1.用户层应用程序调用select(),底层调用poll())

2.核心层调用sys\_select() ------> do\_select()

最终调用文件描述符fd对应的struct file类型变量的struct file\_operations \*f\_op的poll函数。

poll指向的函数返回当前可否读写的信息。

1)如果当前可读写，返回读写信息。

2)如果当前不可读写，则阻塞进程，并等待驱动程序唤醒，重新调用poll函数，或超时返回。

3.驱动需要实现poll函数。

当驱动发现有数据可以读写时，通知核心层，核心层重新调用poll指向的函数查询信息。

poll\_wait(filp,&wait\_q,wait) //  此处将当前进程加入到等待队列中，但并不阻塞

在中断中使用wake\_up\_interruptible(&wait\_q)唤醒等待队列

[http://www.lupaworld.com/151392/viewspace-45283.html][http_www.lupaworld.com_151392_viewspace-45283.html]

===================================================================================

非阻塞式socket编程（**select**() ）

[http://eastsun.blogbus.com/logs/7873846.html][http_eastsun.blogbus.com_logs_7873846.html]

**Select**在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用**Select**写程序，他们只是习惯写诸如connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用**Select**就可以完成非阻塞（所谓非阻塞方式non-block，就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，如果事件发生则与阻塞方式相同，若事件没有发生则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高）方式工作的程序，它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。下面详细介绍一下！  
  
**Select**的函数格式(我所说的是Unix系统下的伯克利socket编程，和windows下的有区别，一会儿说明)：  
  
int **select**(int maxfdp,fd\_set \*readfds,fd\_set \*writefds,fd\_set \*errorfds,struct timeval \*timeout);  
  
先说明两个结构体：  
  
第一，struct fd\_set可以理解为一个集合，这个集合中存放的是文件描述符(file descriptor)，即文件句柄，这可以是我们所说的普通意义的文件，当然Unix下任何设备、管道、FIFO等都是文件形式，全部包括在内，所以毫无疑问一个socket就是一个文件，socket句柄就是一个文件描述符。fd\_set集合可以通过一些宏由人为来操作，比如清空集合FD\_ZERO(fd\_set \*)，将一个给定的文件描述符加入集合之中FD\_SET(int ,fd\_set \*)，将一个给定的文件描述符从集合中删除FD\_CLR(int ,fd\_set\*)，检查集合中指定的文件描述符是否可以读写FD\_ISSET(int ,fd\_set\* )。一会儿举例说明。  
  
第二，struct timeval是一个大家常用的结构，用来代表时间值，有两个成员，一个是秒数，另一个是毫秒数。  
  
具体解释**select**的参数：  
  
int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。  
  
fd\_set \*readfds是指向fd\_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，如果这个集合中有一个文件可读，**select**就会返回一个大于0的值，表示有文件可读，如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，**select**返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。  
  
fd\_set \*writefds是指向fd\_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的写变化的，即我们关心是否可以向这些文件中写入数据了，如果这个集合中有一个文件可写，**select**就会返回一个大于0的值，表示有文件可写，如果没有可写的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，**select**返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的写变化。  
  
fd\_set \*errorfds同上面两个参数的意图，用来监视文件错误异常。  
  
struct timeval\* timeout是**select**的超时时间，这个参数至关重要，它可以使**select**处于三种状态，第一，若将NULL以形参传入，即不传入时间结构，就是将**select**置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；第三，timeout的值大于0，这就是等待的超时时间，即**select**在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。  
  
返回值：  
  
负值：**select**错误 正值：某些文件可读写或出错 0：等待超时，没有可读写或错误的文件  
  
在有了**select**后可以写出像样的网络程序来！举个简单的例子，就是从网络上接受数据写入一个文件中。  
  
例子：  
  
main()  
  
\{  
  
int sock;  
  
FILE \*fp;  
  
struct fd\_set fds;  
  
struct timeval timeout=\{3,0\}; //**select**等待3秒，3秒轮询，要非阻塞就置0  
  
char buffer\[256\]=\{0\}; //256字节的接收缓冲区  
  
/\* 假定已经建立UDP连接，具体过程不写，简单，当然TCP也同理，主机ip和port都已经给定，要写的文件已经打开  
  
sock=socket(...);  
  
bind(...);  
  
fp=fopen(...); \*/  
  
while(1)  
  
\{  
  
FD\_ZERO(&fds); //每次循环都要清空集合，否则不能检测描述符变化  
  
FD\_SET(sock,&fds); //添加描述符  
  
FD\_SET(fp,&fds); //同上  
  
maxfdp=sock>fp?sock+1:fp+1; //描述符最大值加1  
  
switch(**select**(maxfdp,&fds,&fds,NULL,&timeout)) //**select**使用  
  
\{  
  
case -1: exit(-1);break; //**select**错误，退出程序  
  
case 0:break; //再次轮询  
  
default:  
  
if(FD\_ISSET(sock,&fds)) //测试sock是否可读，即是否网络上有数据  
  
\{  
  
recvfrom(sock,buffer,256,.....);//接受网络数据  
  
if(FD\_ISSET(fp,&fds)) //测试文件是否可写  
  
fwrite(fp,buffer...);//写入文件  
  
buffer清空;  
  
\}// end if break;  
  
\}// end switch  
  
\}//end while  
  
\}//end main

==========================================================================

**Linux下用select查询串口数据**

[http://www.wangchao.net.cn/bbsdetail\_68116.html][http_www.wangchao.net.cn_bbsdetail_68116.html]

Linux下直接用read读串口可能会造成堵塞，或数据读出错误。然而用**select**先查询com口，再用read去读就可以避免，并且当com口延时时，程序可以退出，这样就不至于由于com口堵塞，程序就死了。我的代码如下：  
　　bool ReadDevice( int hComm, unsigned long uLen, char\* pData )  
　　\{  
　　 int nread = 0;  
　　 char inbuf\[uLen\];  
　　 char buff\[uLen\];  
　　 memset( inbuff, '\\0', uLen );  
　　 memset( buff, '\\0', uLen );  
　　 fd\_set readset;  
　　 struct timeval tv;  
　　 int MaxFd = 0;  
　　 int c = 0;  
　　 int z;  
　　 do  
　　 \{  
　　 FD\_ZERO( &readset );  
　　 if( hComm >= 0 )  
　　 FD\_SET( hComm, &readset );  
　　 MaxFd = hComm + 1;  
　　 tv.tv\_sec = 0;  
　　 tv.tv\_usec = 500000;  
　　 do  
　　 \{  
　　 z = **select**( MaxFd, &readset, 0, 0, &tv);  
　　 \}while( z==-1 && errno==EINTR );  
　　 if( z == -1 )  
　　 printf("**select**(2)\\n");  
　　 if( z == 0 )  
　　 \{  
　　 hComm = -1;  
　　 \}  
　　  
　　 if( hComm>=0 && FD\_ISSET(hComm, &readset) )  
　　 \{  
　　 z = read( hComm, buff, uLen - c );  
　　 c += z;  
　　 if( z == -1 )  
　　 \{  
　　 hComm = -1;  
　　 \}  
　　 if( z > 0 )  
　　 \{  
　　 buff\[ z + 1 \] = '\\0';  
　　 strcat( inbuff, buff );  
　　 memset( buff, 0x00, uLen );  
　　 \}  
　　 else  
　　 \{  
　　 hComm = -1;  
　　 \}  
　　 \}  
　　 \}while( hComm >= 0 );  
　　 memcpy( pData, inbuff, c );  
　　 return true;  
　　\}

<table> 
 <tbody> 
 <tr> 
 <td> 问题1答案: select返回的是准备就绪的描述符个数，若超时则为0，若出错则为- 1。（参见《UNIX环境高级编程12.5.1节》） （以下参见man select） ... ... RETURN VALUE &nbsp; &nbsp;&nbsp; &nbsp; On success, select and pselect return the number of descriptors contained in the descriptor sets, which may be zero if the &nbsp; &nbsp;&nbsp; &nbsp; timeout&nbsp;&nbsp;expires&nbsp;&nbsp;before anything interesting happens.&nbsp;&nbsp;On error, -1 is returned, and errno is set appropriately; the sets &nbsp; &nbsp;&nbsp; &nbsp; and timeout become undefined, so do not rely on their contents after an error. 问题1答案: select()允许进程指示内核等待多个事件中的任一个发生,并仅在一个或多个事件发生或经过某指定的时间后才唤醒进程。也就是说通知内核我们对哪些描述字感兴趣，我们关心的描述字不受限于套接口,任何描述字都可以用select()来测试。select收集描述符，怎么实现的我不知道，有兴趣看看内核代码吧。 while大循环中，第一次循环应该执行：if(FD_ISSET(listen_id,&amp;rd)) ，执行之后通过accept获得一个客户端的连接，并将描述符放入rd中，那第二次循环是不是应该执行else了呢？ 不是！只有当有新的连接连上监听端口的时候FD_ISSET(listen_id,&amp;rd)才会返回TRUE,否则，就去挨个检查那些已经连上来的客户端连接看有没有消息可以收（注意那个for循环，表明不是每次只能处理一个描述符）。 逻辑是这样的，帮你理顺： 把监听描述字设置到rd； select()返回大于0的话 { &nbsp; &nbsp;&nbsp; &nbsp;if有新的连接连上来 &nbsp; &nbsp; { &nbsp; &nbsp;&nbsp; &nbsp;&nbsp;&nbsp;添加新的连接到rd; &nbsp; &nbsp; } &nbsp; &nbsp; else &nbsp; &nbsp;&nbsp; &nbsp;&nbsp;&nbsp;{ &nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;for&nbsp;&nbsp;所有已有的连接 &nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;{ &nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;收消息 &nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;发消息 &nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;&nbsp; &nbsp;} &nbsp; &nbsp;&nbsp; &nbsp;&nbsp;&nbsp;} } 问题3： select的作用体现在了不需要你自己频繁的去测试哪些文件描述符可读可写或异常，select一次性把你关心的描述字的状态展现在你面前。 假如没有select函数，你就得自己这样写： for (int i=0; i&lt;maxfd; i++) { &nbsp; &nbsp; if accept(...){...}; &nbsp; &nbsp; if recv(...){...}; &nbsp; &nbsp; if send(...){...}; } 这样的频繁的系统调用显然影响效率。 在应用进程中需要对多个I／O设备进行监听，当某个设备可读或可写时，进程能马上得知，并进行相关处理。这时若采用阻塞方式操作I／O，则进程会阻塞在某个设备的I／O读写操作上而不能适用于这种情况；若采用非阻塞方式，则往往需要定时或循环地探测所有设备，才作相应处理，这种作法相当耗费系统中央处理器的执行周期。可见，上述的两个I／O模型都不能满足这类应用，故此需要引入一种特别的I／O处理机制，即I／O多路转接，就是select()。 </td> 
 </tr> 
 </tbody> 
</table>

我来说一下第二点把：

总之问题归结于两点：select是如何收集客户端连接描述符的呢，比如说有5个客户请求连接，而select在又是如何并发处理的呢？

因为不知道内核实如何实现select的，我就说一下我的想法。

1。首先在单处理器里是没有真正的并行处理的，所以就有了并发的概念。

2。就算是真正的同时有5个客户同时请求连接，那处理器也必须一个一个的来处理。

3。实际上select的真正优势是在于可以等待多个文件描述符（当然包括多个套接口）

4。我认为内核可能是让这多个客户连接请求进入队列，然后再一个一个通知select来处理。

=====================================================================================

非阻塞式socket编程select()

http://eastsun.blogbus.com/logs/7873846.html

Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如 connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用Select就可以完成非阻塞（所谓非阻塞方式non- block，就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，如果事件发生则与阻塞方式相同，若事件没有发生则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高）方式工作的程序，它能够监视我们需要监视的文件描述符的变化情况读写或是异常。下面详细介绍一下！

Select的函数格式(我所说的是Unix系统下的伯克利socket编程，和windows下的有区别，一会儿说明)：

int select(int maxfdp,fd\_set \*readfds,fd\_set \*writefds,fd\_set \*errorfds,struct timeval \*timeout);

先说明两个结构体：

第一，struct fd\_set可以理解为一个集合，这个集合中存放的是文件描述符(file descriptor)，即文件句柄，这可以是我们所说的普通意义的文件，当然Unix下任何设备、管道、FIFO等都是文件形式，全部包括在内，所以毫无疑问一个socket就是一个文件，socket句柄就是一个文件描述符。fd\_set集合可以通过一些宏由人为来操作，比如清空集合 FD\_ZERO(fd\_set \*)，将一个给定的文件描述符加入集合之中FD\_SET(int ,fd\_set \*)，将一个给定的文件描述符从集合中删除FD\_CLR(int ,fd\_set\*)，检查集合中指定的文件描述符是否可以读写FD\_ISSET(int ,fd\_set\* )。一会儿举例说明。

第二，struct timeval是一个大家常用的结构，用来代表时间值，有两个成员，一个是秒数，另一个是毫秒数。

具体解释select的参数：

int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。

fd\_set \*readfds是指向fd\_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，如果这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读，如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。

fd\_set \*writefds是指向fd\_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的写变化的，即我们关心是否可以向这些文件中写入数据了，如果这个集合中有一个文件可写，select就会返回一个大于0的值，表示有文件可写，如果没有可写的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的写变化。

fd\_set \*errorfds同上面两个参数的意图，用来监视文件错误异常。

struct timeval\* timeout是select的超时时间，这个参数至关重要，它可以使select处于三种状态，第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；第三，timeout的值大于0，这就是等待的超时时间，即 select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。

返回值：

负值：select错误正值：某些文件可读写或出错 0：等待超时，没有可读写或错误的文件

在有了select后可以写出像样的网络程序来！举个简单的例子，就是从网络上接受数据写入一个文件中。

例子：

main()

int sock;

FILE \*fp;

struct fd\_set fds;

struct timeval timeout=\{3,0\}; //select等待3秒，3秒轮询，要非阻塞就置0

char buffer\[256\]=\{0\}; //256字节的接收缓冲区

/\* 假定已经建立UDP连接，具体过程不写，简单，当然TCP也同理，主机ip和port都已经给定，要写的文件已经打开

sock=socket(...);

bind(...);

fp=fopen(...); \*/

while(1)

FD\_ZERO(&fds); //每次循环都要清空集合，否则不能检测描述符变化

FD\_SET(sock,&fds); //添加描述符

FD\_SET(fp,&fds); //同上

maxfdp=sock>fp?sock+1:fp+1; //描述符最大值加1

switch(select(maxfdp,&fds,&fds,NULL,&timeout)) //select使用

case -1: exit(-1);break; //select错误，退出程序

case 0:break; //再次轮询

default:

if(FD\_ISSET(sock,&fds)) //测试sock是否可读，即是否网络上有数据

recvfrom(sock,buffer,256,.....);//接受网络数据

if(FD\_ISSET(fp,&fds)) //测试文件是否可写

fwrite(fp,buffer...);//写入文件

buffer清空;

\}// end if break;

\}// end switch

\}//end while

\}//end main

\----------------------------------------------------------

Linux select()详解

Linux select()详解select系统调用是用来让我们的程序监视多个文件句柄(file descriptor)的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有某一个或多个发生了状态改变。

文件在句柄在Linux里很多，如果你man某个函数，在函数返回值部分说到成功后有一个文件句柄被创建的都是的，如man socket可以看到“On success, a file descriptor for the new socket is returned.”而man 2 open可以看到“open() and creat() return the new file descriptor”，其实文件句柄就是一个整数，看socket函数的声明就明白了：

int socket(int domain, int type, int protocol);

当然，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE \*结构的表示就是stdin、stdout、stderr，0就是stdin，1就是stdout，2就是stderr。

比如下面这两段代码都是从标准输入读入9个字节字符：

\#include <stdio.h>

\#include <unistd.h>

\#include <string.h>

int main(int argc, char \*\* argv)

char buf\[10\] = "";

read(0, buf, 9); /\* 从标准输入 0读入字符 \*/

fprintf(stdout, "%s\\n", buf); /\* 向标准输出 stdout写字符 \*/

return 0;

/\* \*\*上面和下面的代码都可以用来从标准输入读用户输入的9个字符\*\* \*/

\#include <stdio.h>

\#include <unistd.h>

\#include <string.h>

int main(int argc, char \*\* argv)

char buf\[10\] = "";

fread(buf, 9, 1, stdin); /\* 从标准输入 stdin读入字符 \*/

write(1, buf, strlen(buf));

return 0;

继续上面说的select，就是用来监视某个或某些句柄的状态变化的。select函数原型如下：

int select(int nfds, fd\_set \*readfds, fd\_set \*writefds, fd\_set \*exceptfds, struct timeval \*timeout);

struct timeval \{

long tv\_sec; /\* seconds \*/

long tv\_usec; /\* microseconds \*/

\};

第2、3、4三个参数是一样的类型： fd\_set \*，即我们在程序里要申明几个fd\_set类型的变量，比如rdfds, wtfds, exfds，然后把这个变量的地址&rdfds, &wtfds, &exfds传递给select函数。这三个参数都是一个句柄的集合，第一个rdfds是用来保存这样的句柄的：当句柄的状态变成可读的时系统就会告诉select函数返回，同理第二个wtfds是指有句柄状态变成可写的时系统就会告诉select函数返回，同理第三个参数exfds是特殊情况，即句柄上有特殊情况发生时系统会告诉select函数返回。特殊情况比如对方通过一个socket句柄发来了紧急数据。如果我们程序里只想检测某个socket是否有数据可读，我们可以这样：

fd\_set rdfds; /\*先申明一个 fd\_set集合来保存我们要检测的 socket句柄 \*/

struct timeval tv; /\*申明一个时间变量来保存时间 \*/

int ret; /\*保存返回值 \*/

FD\_ZERO(&rdfds); /\*用select函数之前先把集合清零 \*/

FD\_SET(socket, &rdfds); /\*把要检测的句柄socket加入到集合里 \*/

tv.tv\_sec = 1;

tv.tv\_usec = 500; /\*设置select等待的最大时间为1秒加500毫秒 \*/

ret = select(socket + 1, &rdfds, NULL, NULL, &tv); /\*检测我们上面设置到集合rdfds里的句柄是否有可读信息 \*/

if(ret < 0) perror("select");/\*这说明select函数出错 \*/

else if(ret == 0) printf("超时\\n"); /\*说明在我们设定的时间值1秒加500毫秒的时间内，socket的状态没有发生变化 \*/

else \{ /\*说明等待时间还未到1秒加500毫秒，socket的状态发生了变化 \*/

printf("ret=%d\\n", ret); /\* ret这个返回值记录了发生状态变化的句柄的数目，由于我们只监视了socket这一个句柄，所以这里一定ret=1，如果同时有多个句柄发生变化返回的就是句柄的总和了 \*/

/\* 这里我们就应该从socket这个句柄里读取数据了，因为select函数已经告诉我们这个句柄里有数据可读 \*/

if(FD\_ISSET(socket, &rdfds)) \{ /\* 先判断一下socket这外被监视的句柄是否真的变成可读的了 \*/

/\* 读取socket句柄里的数据 \*/

recv(...);

注意select函数的第一个参数，是所有加入集合的句柄值的最大那个值还要加1。比如我们创建了3个句柄：

/\*\*\*\*\*\*\*\*\*\*\*\*关于本文档\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

\*filename: Linux网络编程一步一步学\-select详解

\*purpose:详细说明select的用法

\*wrote by: zhoulifa(zhoulifa@163.com)周立发(http://zhoulifa.bokee.com)

Linux爱好者 Linux知识传播者 SOHO族开发者最擅长C语言

\*date time:2007-02-03 19:40

\*Note:任何人可以任意复制代码并运用这些文档，当然包括你的商业用途

\* 但请遵循GPL

\*Thanks to:Google

\*Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力

\* 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

int sa, sb, sc;

sa = socket(...); /\*分别创建3个句柄并连接到服务器上 \*/

connect(sa,...);

sb = socket(...);

connect(sb,...);

sc = socket(...);

connect(sc,...);

FD\_SET(sa, &rdfds);/\*分别把3个句柄加入读监视集合里去 \*/

FD\_SET(sb, &rdfds);

FD\_SET(sc, &rdfds);

在使用select函数之前，一定要找到3个句柄中的最大值是哪个，我们一般定义一个变量来保存最大值，取得最大socket值如下：

int maxfd = 0;

if(sa > maxfd) maxfd = sa;

if(sb > maxfd) maxfd = sb;

if(sc > maxfd) maxfd = sc;

然后调用select函数：

ret = select(maxfd + 1, &rdfds, NULL, NULL, &tv); /\*注意是最大值还要加1 \*/

同样的道理，如果我们要检测用户是否按了键盘进行输入，我们就应该把标准输入0这个句柄放到select里来检测，如下：

FD\_ZERO(&rdfds);

FD\_SET(0, &rdfds);

tv.tv\_sec = 1;

tv.tv\_usec = 0;

ret = select(1, &rdfds, NULL, NULL, &tv); /\*注意是最大值还要加1 \*/

if(ret < 0) perror("select");/\*出错 \*/

else if(ret == 0) printf("超时\\n"); /\*在我们设定的时间tv内，用户没有按键盘 \*/

else \{ /\*用户有按键盘，要读取用户的输入 \*/

scanf("%s", buf);

\}----------------------------------------------------------

Linux select学习笔记

select系统调用是用来让我们的程序监视多个文件描述符(file descrīptor)的状态变化的。程序会停在select这里等待，直到被监视的文件描述符有某一个或多个发生了状态改变。select()的机制中提供一fd\_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件描述符（不管是Socket描述符,还是其他文件或命名管道或设备描述符）建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fd\_set的内容，由此来通知执行了select()的进程哪一Socket或文件可读，

select函数原型如下：

int select(int nfds, fd\_set \*readfds, fd\_set \*writefds, fd\_set \*exceptfds, struct timeval \*timeout);

struct timeval \{

long tv\_sec; /\* seconds \*/

long tv\_usec; /\* microseconds \*/

\};

第2、3、4三个参数的类型是一样的： fd\_set \*，即我们在程序里要申明几个fd\_set类型的变量，比如定义了rfds, wfds, efds。

另外关于fd\_set类型的变量，还有一组标准的宏定义来处理此类变量：

FD\_ZERO(fd\_set \*fdset)：清空fdset与所有文件描述符的联系。

FD\_SET(int fd, fd\_set \*fdset)：建立文件描述符fd与fdset的联系。

FD\_CLR(int fd, fd\_set \*fdset)：清除文件描述符fd与fdset的联系。

FD\_ISSET(int fd, fd\_set \*fdset)：检查fd\_set联系的文件描述符fd是否可读写，>0表示可读写。

int fd1, fd2; /\* 在定义两个描述符\*/

fd1 = socket(...); /\* 创建socket连接\*/

fd2 = open(“/dev/tyS0”,O\_RDWR); /\* 打开一个串口\*/

FD\_ZERO(&rfds); /\* 用select函数之前先把集合清零 \*/

FD\_SET(fd1, &rfds); /\* 分别把2个描述符加入读监视集合里去 \*/

FD\_SET(fd2, &rfds);

int maxfd = 0;

maxfd = (fd1>fd2)?(fd1+1):(fd2+1); /\* 注意是最大值还要加1 \*/

ret = select(maxfd, &rfds, NULL, NULL, &tv); /\*然后调用select函数\*/

这样就可以使用一个开关语句（switch语句）来判断到底是哪一个输入源在输入数据。具体判断如下：

switch（ret）\{

case -1：perror("select");/\*这说明select函数出错 \*/

case 0：printf("超时\\n"); /\* 说明在设定的时间内，socket的状态没有发生变化 \*/

default：

if（FD\_ISSET(fd1, &rfds)）处理函数1（）；/\*socket有数据来\*/

if（FD\_ISSET(fd2, &rfds)）处理函数2（）；/\*ttyS0有数据来\*/

以下来自网络搜索：

Linux下select调用的过程:

1.用户层应用程序调用select(),底层调用poll())

2.核心层调用sys\_select() ------> do\_select()

最终调用文件描述符fd对应的struct file类型变量的struct file\_operations \*f\_op的poll函数。

poll指向的函数返回当前可否读写的信息。

1)如果当前可读写，返回读写信息。

2)如果当前不可读写，则阻塞进程，并等待驱动程序唤醒，重新调用poll函数，或超时返回。

3.驱动需要实现poll函数。

当驱动发现有数据可以读写时，通知核心层，核心层重新调用poll指向的函数查询信息。

poll\_wait(filp,&wait\_q,wait) //此处将当前进程加入到等待队列中，但并不阻塞

在中断中使用wake\_up\_interruptible(&wait\_q)唤醒等待队列

\----------------------------------------------------------

Socket编程中select()的妙用

用过 WinSock API网友们知道：WinSock编程中有一很方便的地方便是其

息驱动机制，不管是底层 API的 WSAAsyncSelect()还是 MFC的异步Socket类：

CAsyncSocket，都提供了诸如 FD\_ACCEPT、FD\_READ、FD\_CLOSE之类的消息

供编程人员捕捉并处理。FD\_ACCEPT通知进程有客户方Socket请求连接，

FD\_READ通知进程本地Socket有东东可读，FD\_CLOSE通知进程对方Socket已

关闭。那么，BSD Socket是不是真的相形见拙呢？

非也！ 'cause cpu love unix so.

BSD UNIX中有一系统调用芳名select()完全可以提供类似的消息驱动机制。

cpu郑重宣布：WinSock的WSAAsyncSeclet()不过是此select()的fork版！

bill也是fork出来的嘛，xixi.

select()的机制中提供一fd\_set的数据结构，实际上是一long类型的数组，

每一个数组元素都能与一打开的文件句柄（不管是Socket句柄,还是其他

文件或命名管道或设备句柄）建立联系，建立联系的工作由程序员完成，

当调用select()时，由内核根据IO状态修改fd\_set的内容，由此来通知执

行了select()的进程哪一Socket或文件可读，下面具体解释：

\#include <sys/types.h>

\#include <sys/times.h>

\#include <sys/select.h>

int select(nfds, readfds, writefds, exceptfds, timeout)

int nfds;

fd\_set \*readfds, \*writefds, \*exceptfds;

struct timeval \*timeout;

ndfs：select监视的文件句柄数，视进程中打开的文件数而定,一般设为呢要监视各文件

中的最大文件号加一。

readfds：select监视的可读文件句柄集合。

writefds: select监视的可写文件句柄集合。

exceptfds：select监视的异常文件句柄集合。

timeout：本次select()的超时结束时间。（见/usr/sys/select.h，

可精确至百万分之一秒！）

当readfds或writefds中映象的文件可读或可写或超时，本次select()

就结束返回。程序员利用一组系统提供的宏在select()结束时便可判

断哪一文件可读或可写。对Socket编程特别有用的就是readfds。

几只相关的宏解释如下：

FD\_ZERO(fd\_set \*fdset)：清空fdset与所有文件句柄的联系。

FD\_SET(int fd, fd\_set \*fdset)：建立文件句柄fd与fdset的联系。

FD\_CLR(int fd, fd\_set \*fdset)：清除文件句柄fd与fdset的联系。

FD\_ISSET(int fd, fdset \*fdset)：检查fdset联系的文件句柄fd是否

可读写，>0表示可读写。

（关于fd\_set及相关宏的定义见/usr/include/sys/types.h）

这样，你的socket只需在有东东读的时候才读入，大致如下：

...

int sockfd;

fd\_set fdR;

struct timeval timeout = ..;

...

for(;;) \{

FD\_ZERO(&fdR);

FD\_SET(sockfd, &fdR);

switch (select(sockfd + 1, &fdR, NULL, &timeout)) \{

case -1:

error handled by u;

case 0:

timeout hanled by u;

default:

if (FD\_ISSET(sockfd)) \{

now u read or recv something;

/\* if sockfd is father and

server socket, u can now

accept() \*/

所以一个FD\_ISSET(sockfd)就相当通知了sockfd可读。

至于struct timeval在此的功能，请man select。不同的timeval设置

使使select()表现出超时结束、无超时阻塞和轮询三种特性。由于

timeval可精确至百万分之一秒，所以Windows的SetTimer()根本不算

什么。你可以用select()做一个超级时钟。

FD\_ACCEPT的实现？依然如上，因为客户方socket请求连接时，会发送

连接请求报文，此时select()当然会结束，FD\_ISSET(sockfd)当然大

于零，因为有报文可读嘛！至于这方面的应用，主要在于服务方的父

Socket，你若不喜欢主动accept()，可改为如上机制来accept()。

至于FD\_CLOSE的实现及处理，颇费了一堆cpu处理时间，未完待续。

\--

讨论关于利用select()检测对方Socket关闭的问题：

仍然是本地Socket有东东可读，因为对方Socket关闭时，会发一个关闭连接

通知报文，会马上被select()检测到的。关于TCP的连接（三次握手）和关

闭（二次握手）机制，敬请参考有关TCP/IP的书籍。

不知是什么原因，UNIX好象没有提供通知进程关于Socket或Pipe对方关闭的

信号，也可能是cpu所知有限。总之，当对方关闭，一执行recv()或read()，

马上回返回\-1，此时全局变量errno的值是115，相应的sys\_errlist\[errno\]

为"Connect refused"（请参考/usr/include/sys/errno.h）。所以，在上

篇的for(;;)...select()程序块中，当有东西可读时，一定要检查recv()或

read()的返回值，返回\-1时要作出关断本地Socket的处理，否则select()会

一直认为有东西读，其结果曾几令cpu伤心欲断针脚。不信你可以试试：不检

查recv()返回结果，且将收到的东东（实际没收到）写至标准输出...

在有名管道的编程中也有类似问题出现。具体处理详见拙作：发布一个有用

的Socket客户方原码。

至于主动写Socket时对方突然关闭的处理则可以简单地捕捉信号SIGPIPE并作

出相应关断本地Socket等等的处理。SIGPIPE的解释是：写入无读者方的管道。

在此不作赘述，请详man signal。

以上是cpu在作tcp/ip数据传输实验积累的经验，若有错漏，请狂炮击之。

唉，昨天在hacker区被一帮孙子轰得差点儿没短路。ren cpu(奔腾的心) z80

补充关于select在异步(非阻塞)connect中的应用,刚开始搞socket编程的时候

我一直都用阻塞式的connect,非阻塞connect的问题是由于当时搞proxy scan

而提出的呵呵

通过在网上与网友们的交流及查找相关FAQ,总算知道了怎么解决这一问题.同样

用select可以很好地解决这一问题.大致过程是这样的:

1.将打开的socket设为非阻塞的,可以用fcntl(socket, F\_SETFL, O\_NDELAY)完

成(有的系统用FNEDLAY也可).

2.发connect调用,这时返回\-1,但是errno被设为EINPROGRESS,意即connect仍旧

在进行还没有完成.

3.将打开的socket设进被监视的可写(注意不是可读)文件集合用select进行监视,

如果可写,用

getsockopt(socket, SOL\_SOCKET, SO\_ERROR, &error, sizeof(int));

来得到error的值,如果为零,则connect成功.

在许多unix版本的proxyscan程序你都可以看到类似的过程,另外在solaris精华

区\->编程技巧中有一个通用的带超时参数的connect模块.

===================================================================================

socket中 select使用指南

原型

int select(

int nfds

fd\_set\* readfds

fd\_set\* writefds

fd\_set\* exceptfds

const struct timeval\* timeout

);

第一个参数 nfds

在linux下的描述：指定测试的描述符最大值，在0到nfds都会被测试，

到了windows下： Ignored. The nfds parameter is included only for compatibility with Berkeley sockets. 忽略了。

从accept开始.

首先:

SOCKET sock;

sock= socket(AF\_INETSOCK\_STREAM0);

struct sockaddr\_in addr; //告诉sock应该再什么地方licence

memset(&addr0sizeof(addr));

addr.sin\_family=AF\_INET;

addr.sin\_port=htons(11111); //端口啦

addr.sin\_addr.s\_addr=htonl(INADDR\_ANY); //在本机的所有ip上开始监听

bind (sock(sockaddr \*)&addrsizeof(addr));//bind....

listen(sock5); ;//最大5个队列

SOCKET socka; //这个用来接受一个连接

fd\_set rfd; //描述符集这个将用来测试有没有一个可用的连接

struct timeval timeout;

FD\_ZERO(&rfd); //总是这样先清空一个描述符集

timeout.tv\_sec=60; //等下select用到这个

timeout.tv\_usec=0;

u\_long ul=1;

ioctlsocket(sockFIONBIO&ul); //用非阻塞的连接

//现在开始用select

FD\_SET(sock&rfd); //把sock放入要测试的描述符集就是说把sock放入了rfd里面这样下一步调用select对rfd进行测试的时候就会测试sock了(因为我们将sock放入的rdf)一个描述符集可以包含多个被测试的描述符

if(select(sock+1&rfd00 &timeout)==0) // select的第一个参数是可以忽略的(这样写是为了保持和linux下一致)第二个参数放入需要测试的读描述符集(也就是说假如这里面有一个描述符可以读取了select就返回)第三个放入需要测试的写描述符集第四个放入"可执行描述符集"(??我也不知道)第五个参数是超时时间(如果过了这个超时时间依然没有描述符预备好select也返回.(如果为NULL那就一直等到一个描述符集变成准备好的状态)

\{ //这个大括号接上面的返回0那么就超过了timeout预定的时间

//处理....

if(FD\_ISSET(sock&rfd))

\{ //有一个描述符准备好了

socka=accept(sock00); //好了接受它吧

//你还要判定一下socka是不是有效的socket才行....

\-------------------------------------------------------------------------------------------------------------------------------

一般的情况下

假设你要判断两个socket是否可读可写那就这样:

假设 socka和sockb是两个socket他们已经被连接上并且能够收发数据

fd\_set rfdwfd;//一个用来测试读一个用来测试写

FD\_ZERO(&rfd);

FD\_ZERO(&wfd);

FD\_SET(socka&rfd);//把socka放入读描述符集

FD\_SET(sockb&rfd);//把sockb放入读描述符集

FD\_SET(socka&wfd);把socka放入写描述符集

原型

int select(

int nfds

fd\_set\* readfds

fd\_set\* writefds

fd\_set\* exceptfds

const struct timeval\* timeout

);

第一个参数 nfds

在linux下的描述：指定测试的描述符最大值，在0到nfds都会被测试，

到了windows下： Ignored. The nfds parameter is included only for compatibility with Berkeley sockets. 忽略了。

从accept开始.

首先:

SOCKET sock;

sock= socket(AF\_INETSOCK\_STREAM0);

struct sockaddr\_in addr; //告诉sock应该再什么地方licence

memset(&addr0sizeof(addr));

addr.sin\_family=AF\_INET;

addr.sin\_port=htons(11111); //端口啦

addr.sin\_addr.s\_addr=htonl(INADDR\_ANY); //在本机的所有ip上开始监听

bind (sock(sockaddr \*)&addrsizeof(addr));//bind....

listen(sock5); ;//最大5个队列

SOCKET socka; //这个用来接受一个连接

fd\_set rfd; //描述符集这个将用来测试有没有一个可用的连接

struct timeval timeout;

FD\_ZERO(&rfd); //总是这样先清空一个描述符集

timeout.tv\_sec=60; //等下select用到这个

timeout.tv\_usec=0;

u\_long ul=1;

ioctlsocket(sockFIONBIO&ul); //用非阻塞的连接

//现在开始用select

\{ //这个大括号接上面的返回0那么就超过了timeout预定的时间

//处理....

if(FD\_ISSET(sock&rfd))

\{ //有一个描述符准备好了

socka=accept(sock00); //好了接受它吧

//你还要判定一下socka是不是有效的socket才行....

\-------------------------------------------------------------------------------------------------------------------------------

一般的情况下

假设你要判断两个socket是否可读可写那就这样:

假设 socka和sockb是两个socket他们已经被连接上并且能够收发数据

fd\_set rfdwfd;//一个用来测试读一个用来测试写

FD\_ZERO(&rfd);

FD\_ZERO(&wfd);

FD\_SET(socka&rfd);//把socka放入读描述符集

FD\_SET(sockb&rfd);//把sockb放入读描述符集

FD\_SET(socka&wfd);把socka放入写描述符集

FD\_SET(sockb&wfd);把sockb放入写描述符集

if(SOCKET\_ERROR!=select(0&rfd&wfd00)) //测试这两个描述符集永不超时其中rfd只用来测试读 wfd只用来测试写

\{ //没有错误

if(FD\_ISSET(socka&rfd)) //socka可读

\{...\}

if(FD\_ISSET(sockb&rfd) //sockb可读

\{...\}

if(FD\_ISSET(socka&wfd) //socka可写

\{...\}

if(FD\_ISSET(sockb&wfd) //sockb可写

\{...\}

========================================================================

Select函数的应用

今天在读取一个485串口设备的时候遇到了select函数，开始一直不明白该函数的作用。

在网上查找了select函数的用法后，才知道该函数的精妙用法，因为该485设备需要写入一串命令，然后读取该设备，得到想要的数据，但是在写入读取的过程中就会碰到何时读取的问题，因为485设备得到命令后会有一个间隔时间，所以在读取过程中会碰到不知485设备何时预备好了数据的问题，select函数很好的解决了这一问题。

对于这个问题，除了select函数，我还没有看到更好的解决方法。

网上更多的是select函数在socket通信中的应用，由于socket通信部分的学习刚刚开始，就留待以后跟大家探讨。

int select(int maxfdpfd\_set \*readfdsfd\_set \*writefdsfd\_set \*errorfdsstruct timeval \*timeout);

先说明两个结构体：

第一，struct fd\_set可以理解为一个集合，这个集合中存放的是文件描述符(file descriptor)，即文件句柄，这可以是我们所说的普通意义的文件，当然Unix下任何设备、管道、FIFO等都是文件形式，全部包括在内，所以毫无疑问一个socket就是一个文件，socket句柄就是一个文件描述符。fd\_set集合可以通过一些宏由人为来操作，比如清空集合FD\_ZERO(fd\_set \*)，将一个给定的文件描述符加入集合之中FD\_SET(int fd\_set \*)，将一个给定的文件描述符从集合中删除FD\_CLR(int fd\_set\*)，检查集合中指定的文件描述符是否可以读写FD\_ISSET(int fd\_set\* )。一会儿举例说明。

第二，struct timeval是一个大家常用的结构，用来代表时间值，有两个成员，一个是秒数，另一个是毫秒数。

详细解释select的参数：

int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不准确。

fd\_set \*readfds是指向fd\_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，假如这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读，如果没有可读的文件，则根据timeout参数再判定是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。

fd\_set \*errorfds同上面两个参数的意图，用来监视文件错误异常。

struct timeval\* timeout是select的超时时间，这个参数至关重要，它可以使select处于三种状态，第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都马上返回继承执行，文件无变化返回0，有变化返回一个正值；第三，timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。

返回值：

负值：select错误正值：某些文件可读写或出错 0：等待超时，没有可读写或错误的文件

在有了select后可以写出像样的网络程序来！举个简朴的例子，就是从网络上接受数据写入一个文件中。

函数说明：

select()用来等待文件描述词状态的改变。参数maxfdp代表最大的文件描述词加1，参数readfds、writefds和exceptfds称为描述词组，是用往返传该描述词的读，写或例外的状况。底下的宏提供了处理这三种描述词组的方式:

FD\_CLR(inr fdfd\_set\* set)；用来清除描述词组set中相关fd的位

FD\_ISSET(int fdfd\_set \*set)；用来测试描述词组set中相关fd的位是否为真

FD\_SET（int fdfd\_set\*set）；用来设置描述词组set中相关fd的位

FD\_ZERO（fd\_set \*set）；用来清除描述词组set的全部位

===================================================================================

linux编程select函数处理I/O复用(转载)

阻塞操作是指，在执行设备操作时，若不能获得资源，则进程挂起直到满意可操作的条件再进行操作。非阻塞操作的进程在不能进行设备操作时，并不挂起。被挂起的进程进入sleep状态，被从调度器的运行队列移走，直到等待的条件被满意。

其中，select的I/O多路转接模型是处理Ｉ／Ｏ复用的一个高效的方法。

下面是 select()：

\#include ;

int select(int numfds fd\_set \*readfds fd\_set \*writefdsfd\_set

\*exceptfds struct timeval \*timeout);

这个函数监视一系列文件描述符，特殊是 readfds、writefds和 exceptfds。假如你想知道你是否能够从标准输入和套接字描述符 sockfd读入数据，你只要将文件描述符 0和 sockfd加入到集合 readfds中。参数 numfds应该等于最高的文件描述符的值加1。在这个例子中，你应该设置该值为 sockfd+1。因为它一定大于标准输入的文件描述符 (0)。当函数 select() 返回的时候，readfds的值修改为反映你选择的哪个文件描述符可以读。你可以用下面讲到的宏 FD\_ISSET()来测试。在我们继承下去之前，让我来讲讲如何对这些集合进行操作。每个集合类型都是 fd\_set。下面有一些宏来对这个类型进行操作：

FD\_ZERO(fd\_set \*set)–清除一个文件描述符集合

FD\_SET(int fd fd\_set \*set) -添加fd到集合

FD\_CLR(int fd fd\_set \*set)–从集合中移去fd

FD\_ISSET(int fd fd\_set \*set)–测试fd是否在集合中

最后，是有点古怪的数据结构 struct timeval。有时你可不想永远等待别人发送数据过来。也许什么事情都没有发生的时候你也想每隔96秒在终端上打印字符串 "Still Going..."。这个数据结构答应你设定一个时间，假如时间到了，而 select()还没有找到一个预备好的文件描述符，它将返回让你继承处理。

数据结构 struct timeval是这样的：

struct timeval \{

int tv\_sec; /\* seconds \*/

int tv\_usec; /\* microseconds \*/

\};

只要将 tv\_sec设置为你要等待的秒数，将 tv\_usec设置为你要等待的微秒数就可以了。当然，函数返回的时候 timeout可能是剩余的时间，之所以是可能，是因为它依靠于你的 Unix操作系统。

哈！我们现在有一个微秒级的定时器！别计算了，标准的 Unix系统的时间片是100毫秒，所以无论你如何设置你的数据结构 struct timeval，你都要等待那么长的时间。

还有一些有趣的事情：如果你设置数据结构 struct timeval中的数据为 0，select()将立刻超时，这样就可以有效地轮询集合中的所有的文件描述符。如果你将参数 timeout赋值为 NULL，那么将永远不会发生超时，即一直等到第一个文件描述符就绪。最后，如果你不是很关心等待多长时间，那么就把它赋为 NULL 吧。

下面的代码演示了在标准输入上等待 2.5秒：

\#include ;

\#define STDIN 0 /\* file descriptor for standard input \*/

main()

struct timeval tv;

fd\_set readfds;

tv.tv\_sec = 2;

tv.tv\_usec = 500000;

FD\_ZERO(&readfds);

FD\_SET(STDIN &readfds);

/\* don't care about writefds and exceptfds: \*/

select(STDIN+1 &readfds NULL NULL &tv);

if (FD\_ISSET(STDIN &readfds))

printf("A key was pressed!\\n");

else

printf("Timed out.\\n");

如果你是在一个 line buffered终端上，那么你敲的键应该是回车 (RETURN)，否则无论如何它都会超时。

现在，你可能回认为这就是在数据报套接字上等待数据的方式\--你是对的：它可能是。有些 Unix 系统可以按这种方式，而另外一些则不能。你在尝试以前可能要先看看本系统的 man page了。

最后一件关于 select()的事情：如果你有一个正在侦听 (listen())的套接字，你可以通过将该套接字的文件描述符加入到 readfds集合中来看是否有新的连接。

这就是我关于函数select()要讲的所有的东西。

一般来说，在使用select函数之前，首先使用FD\_ZERO和FD\_SET来初始化文件描述符集，在使用了select函数时，可循环使用FD\_ISSET测试描述符集，在执行完对相关后文件描述符后，使用FD\_CLR来清除描述符集。

本例主要实现将文件hello1里的内容读出，并将此内容每隔１０s写入hello2中。在这里建立了两个描述符集，其中一个描述符集inset1是用于读取文件内容，另一个inset2是用于写入文件。两个文件描述符fds\[0\]和 fds\[1\]分别指向这一文件描述符。在首先初始化完各文件描述符集之后，就开始了循环测试这两个文件描述符是否读写，由于在这里没有阻塞，所以文件描述符处理预备就绪的状态。这时，就分别对文件描述符fds\[0\]fds\[1\]进行读写操作。

\#include

int main(void)\{

int fds\[2\];

char buf\[7\];

int ircmaxfd;

fd\_set inset1inset2;

struct timeval tv;

if ((fds\[0\]=open("hello1"O\_CREAT | O\_RDWR0666))0)\{

buf\[rc\]='\\0';

printf("rc=%dwrite:%s\\n"rcbuf);

else

perror("wirte");

sleep(10);

exit(0);

=================================================================================

select函数的学习

select系统调用是用来让我们的程序监视多个文件描述符(file descrīptor)的状态变化的。程序会停在select这里等待，直到被监视的文件描述符有某一个或多个发生了状态改变。select()的机制中提供一fd\_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件描述符（不管是Socket描述符,还是其他文件或命名管道或设备描述符）建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fd\_set的内容，由此来通知执行了select()的进程哪一Socket或文件可读，

select函数原型如下：

int select(int nfds, fd\_set \*readfds, fd\_set \*writefds, fd\_set \*exceptfds, struct timeval \*timeout);

struct timeval \{

long tv\_sec; /\* seconds \*/

long tv\_usec; /\* microseconds

第2、3、4三个参数的类型是一样的： fd\_set \*，即我们在程序里要申明几个fd\_set类型的变量，比如定义了rfds, wfds, efds。

另外关于fd\_set类型的变量，还有一组标准的宏定义来处理此类变量：

FD\_ZERO(fd\_set \*fdset)：清空fdset与所有文件描述符的联系。

FD\_SET(int fd, fd\_set \*fdset)：建立文件描述符fd与fdset的联系。

FD\_CLR(int fd, fd\_set \*fdset)：清除文件描述符fd与fdset的联系。

FD\_ISSET(int fd, fd\_set \*fdset)：检查fd\_set联系的文件描述符fd是否可读写，>0表示可读写。

int fd1, fd2; /\* 在定义两个描述符\*/

fd1 = socket(...); /\* 创建socket连接\*/

fd2 = open(“/dev/tyS0”,O\_RDWR); /\* 打开一个串口\*/

FD\_ZERO(&rfds); /\* 用select函数之前先把集合清零 \*/

FD\_SET(fd1, &rfds); /\* 分别把2个描述符加入读监视集合里去 \*/

FD\_SET(fd2, &rfds);

int maxfd = 0;

maxfd = (fd1>fd2)?(fd1+1):(fd2+1); /\* 注意是最大值还要加1 \*/

ret = select(maxfd, &rfds, NULL, NULL, &tv); /\*然后调用select函数\*/

这样就可以使用一个开关语句（switch语句）来判断到底是哪一个输入源在输入数据。具体判断如下：

switch（ret）\{

case -1：perror("select");/\*这说明select函数出错 \*/

case 0：printf("超时\\n"); /\* 说明在设定的时间内，socket的状态没有发生变化 \*/

default：

if（FD\_ISSET(fd1, &rfds)）处理函数1（）；/\*socket有数据来\*/

if（FD\_ISSET(fd2, &rfds)）处理函数2（）；/\*ttyS0有数据来\*/

==========================================================

多路复用I/O

为了解决创建子进程带来的系统资源消耗,人们又想出了多路复用I/O模型.

首先介绍一个函数select

int select(int nfds,fd\_set \*readfds,fd\_set \*writefds,

fd\_set \*except fds,struct timeval \*timeout)

void FD\_SET(int fd,fd\_set \*fdset)

void FD\_CLR(int fd,fd\_set \*fdset)

void FD\_ZERO(fd\_set \*fdset)

int FD\_ISSET(int fd,fd\_set \*fdset)

一般的来说当我们在向文件读写时,进程有可能在读写出阻塞,直到一定的条件满足.比如我们从一个套接字读数据时,可能缓冲区里面没有数据可读(通信的对方还没有发送数据过来),这个时候我们的读调用就会等待(阻塞)直到有数据可读.如果我们不希望阻塞,我们的一个选择是用select系统调用.只要我们设置好select的各个参数,那么当文件可以读写的时候select回"通知"我们说可以读写了. readfds所有要读的文件文件描述符的集合

writefds所有要的写文件文件描述符的集合

exceptfds其他的服要向我们通知的文件描述符

timeout超时设置.

nfds所有我们监控的文件描述符中最大的那一个加1

在我们调用select时进程会一直阻塞直到以下的一种情况发生. 1)有文件可以读.2)有文件可以写.3)超时所设置的时间到.

为了设置文件描述符我们要使用几个宏. FD\_SET将fd加入到fdset

FD\_CLR将fd从fdset里面清除

FD\_ZERO从fdset中清除所有的文件描述符

FD\_ISSET判断fd是否在fdset集合中

使用select的一个例子

int use\_select(int \*readfd,int n)

fd\_set my\_readfd;

int maxfd;

int i;

maxfd=readfd\[0\];

for(i=1;i if(readfd\[i\]>maxfd) maxfd=readfd\[i\];

while(1)

/\* 将所有的文件描述符加入\*/

FD\_ZERO(&my\_readfd);

for(i=0;i FD\_SET(readfd\[i\],\*my\_readfd);

/\* 进程阻塞\*/

select(maxfd+1,& my\_readfd,NULL,NULL,NULL);

/\* 有东西可以读了\*/

for(i=0;i if(FD\_ISSET(readfd\[i\],&my\_readfd))

/\* 原来是我可以读了\*/

we\_read(readfd\[i\]);

使用select后我们的服务器程序就变成了.

初始话(socket,bind,listen);

while(1)

设置监听读写文件描述符(FD\_\*);

调用select;

如果是倾听套接字就绪,说明一个新的连接请求建立

建立连接(accept);

加入到监听文件描述符中去;

否则说明是一个已经连接过的描述符

进行操作(read或者write);

多路复用I/O可以解决资源限制的问题.着模型实际上是将UDP循环模型用在了TCP上面.这也就带来了一些问题.如由于服务器依次处理客户的请求,所以可能会导致有的客户会等待很久.

===========================================================================

[http_www.lupaworld.com_151392_viewspace-45283.html]: http://www.lupaworld.com/151392/viewspace-45283.html
[http_eastsun.blogbus.com_logs_7873846.html]: http://eastsun.blogbus.com/logs/7873846.html
[http_www.wangchao.net.cn_bbsdetail_68116.html]: http://www.wangchao.net.cn/bbsdetail_68116.html