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
===================================================================================
非阻塞式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查询串口数据
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;
}
问题1答案: |
我来说一下第二点把:
总之问题归结于两点: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);
函数的最后一个参数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类型的变量,比如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);
函数的最后一个参数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)唤醒等待队列
----------------------------------------------------------
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
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放入写描述符集
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 *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后可以写出像样的网络程序来!举个简朴的例子,就是从网络上接受数据写入一个文件中。
函数说明:
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多路转接模型是处理I/O复用的一个高效的方法。
下面是 select():
#include ;
#include ;
#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 ;
#include ;
#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里的内容读出,并将此内容每隔10s写入hello2中。在这里建立了两个描述符集,其中一个描述符集inset1是用于读取文件内容,另一个inset2是用于写入文件。两个文件描述符fds[0]和 fds[1]分别指向这一文件描述符。在首先初始化完各文件描述符集之后,就开始了循环测试这两个文件描述符是否读写,由于在这里没有阻塞,所以文件描述符处理预备就绪的状态。这时,就分别对文件描述符fds[0]fds[1]进行读写操作。
#include
#include
#include
#include
#include
#include
#include
#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);
函数的最后一个参数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有数据来*/
}
==========================================================
多路复用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上面.这也就带来了一些问题.如由于服务器依次处理客户的请求,所以可能会导致有的客户会等待很久.
===========================================================================