socket编程 select(转）

I-linux

作一个tcp的服务程序，同时可能有大量的客户端连上来，希望分别记住各个socket
谁有数据过来，就读出来，放到一个请求队列－－这些事情用一个线程完成
另外有一个结果队列，如果结果里包含了socket的编号，用一个线程专门：
取出来按编号找回原来发送者socket，发回给原来的客户端
还有一个就是处理线程（池），它取出请求队列里的一个请求，进行处理，
把处理结果放入结果队列
不知道有没有现成的框架？
网上只找到一些很。。。的：
http://fanqiang.chinaunix.net/a4/b7/20010508/112359.html
Linux网络编程--9. 服务器模型
http://linuxc.51.net
作者:hoyt (2001-05-08 11:23:59)
    学习过《软件工程》吧.软件工程可是每一个程序员"必修"的课程啊.如果你没有学习过, 建议你去看一看. 在这一章里面,我们一起来从软件工程的角度学习网络编程的思想.在我们写程序之前, 我们都应该从软件工程的角度规划好我们的软件,这样我们开发软件的效率才会高. 在网络程序里面,一般的来说都是许多客户机对应一个服务器.为了处理客户机的请求, 对服务端的程序就提出了特殊的要求.我们学习一下目前最常用的服务器模型.  
循环服务器:循环服务器在同一个时刻只可以响应一个客户端的请求  
并发服务器:并发服务器在同一个时刻可以响应多个客户端的请求  
9.1 循环服务器:UDP服务器  
UDP循环服务器的实现非常简单:UDP服务器每次从套接字上读取一个客户端的请求,处理, 然后将结果返回给客户机.  
可以用下面的算法来实现.  
   socket(...);
   bind(...);
   while(1)
    {
         recvfrom(...);
         process(...);
         sendto(...);
   }
因为UDP是非面向连接的,没有一个客户端可以老是占住服务端. 只要处理过程不是死循环, 服务器对于每一个客户机的请求总是能够满足.  
9.2 循环服务器:TCP服务器  
TCP循环服务器的实现也不难:TCP服务器接受一个客户端的连接,然后处理,完成了这个客户的所有请求后,断开连接.  
算法如下:  
        socket(...);
        bind(...);
        listen(...);
        while(1)
        {
                accept(...);
                while(1)
                {
                        read(...);
                        process(...);
                        write(...);
                }
                close(...);
        }
TCP循环服务器一次只能处理一个客户端的请求.只有在这个客户的所有请求都满足后, 服务器才可以继续后面的请求.这样如果有一个客户端占住服务器不放时,其它的客户机都不能工作了.因此,TCP服务器一般很少用循环服务器模型的.  
9.3 并发服务器:TCP服务器  
为了弥补循环TCP服务器的缺陷,人们又想出了并发服务器的模型. 并发服务器的思想是每一个客户机的请求并不由服务器直接处理,而是服务器创建一个 子进程来处理.  
算法如下:  
  socket(...);
  bind(...);
  listen(...);
  while(1)
  {
        accept(...);
        if(fork(..)==0)
          {
              while(1)
               {         
                read(...);
                process(...);
                write(...);
               }
           close(...);
           exit(...);
          }
        close(...);
  }      
TCP并发服务器可以解决TCP循环服务器客户机独占服务器的情况. 不过也同时带来了一个不小的问题.为了响应客户机的请求,服务器要创建子进程来处理. 而创建子进程是一种非常消耗资源的操作.  
9.4 并发服务器:多路复用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>maxfd) maxfd=readfd;
   while(1)
   {
        /*   将所有的文件描述符加入   */
        FD_ZERO(&my_readfd);
        for(i=0;i            FD_SET(readfd,*my_readfd);
        /*     进程阻塞                 */
        select(maxfd+1,& my_readfd,NULL,NULL,NULL);  
        /*        有东西可以读了       */
        for(i=0;i          if(FD_ISSET(readfd,&my_readfd))
              {
                  /* 原来是我可以读了  */  
                        we_read(readfd);
              }
   }
}
使用select后我们的服务器程序就变成了.  
        初始话(socket,bind,listen);
         
    while(1)
        {
        设置监听读写文件描述符(FD_*);   
         
        调用select;
         
        如果是倾听套接字就绪,说明一个新的连接请求建立
             {  
                建立连接(accept);
                加入到监听文件描述符中去;
             }
       否则说明是一个已经连接过的描述符
                {
                    进行操作(read或者write);
                 }
                        
        }               
多路复用I/O可以解决资源限制的问题.着模型实际上是将UDP循环模型用在了TCP上面. 这也就带来了一些问题.如由于服务器依次处理客户的请求,所以可能会导致有的客户 会等待很久.  
9.5 并发服务器:UDP服务器  
人们把并发的概念用于UDP就得到了并发UDP服务器模型. 并发UDP服务器模型其实是简单的.和并发的TCP服务器模型一样是创建一个子进程来处理的 算法和并发的TCP模型一样.  
除非服务器在处理客户端的请求所用的时间比较长以外,人们实际上很少用这种模型.  
9.6 一个并发TCP服务器实例  
#include  
#include  
#include  
#include  
#include  
#define MY_PORT         8888
int main(int argc ,char **argv)
{
int listen_fd,accept_fd;
struct sockaddr_in     client_addr;
int n;
  
if((listen_fd=socket(AF_INET,SOCK_STREAM,0))
        close(listen_fd);
        n=read(accept_fd,buffer,1024);
        write(accept_fd,buffer,n);
        close(accept_fd);
        exit(0);
   }
   else if(n
你可以用我们前面写客户端程序来调试着程序,或者是用来telnet调试  


http://www.csdn.com.cn/program/6713.htm
Linux网络服务器
   浏览选项： 大中小  颜色 默认 灰度 橄榄色 绿色 蓝色 褐色 红色   

   
  

     Linux系统网络服务器模型主要有两种：并发服务器和循环服务器。所谓并发服务器就是在同一个时刻可以处理来自多个客户端的请求；循环服务器是指服务器在同一时刻指可以响应一个客户端的请求。而且对于TCP和UDP套接字，这两种服务器的实现方式也有不同的特点。
1、TCP循环服务器：首先TCP服务器接受一个客户端的连接请求，处理连接请求，在完成这个客户端的所有请求后断开连接，然后再接受下一个客户端的请求。
   创建TCP循环服务器的算法如下：
    socket(……)；   //创建一个TCP套接字
    bind(……)；      //邦定公认的端口号
    listen(……）；  //倾听客户端连接
    while(1）          //开始循环接收客户端连接
   {
                accept(……)；//接收当前客户端的连接
                while(1)
                 {                    //处理当前客户端的请求
                         read(……）；
                         process(……);
                          write(……);
                 }
                close(……);   //关闭当前客户端的连接，准备接收下一个客户端连接
    }
TCP循环服务器一次只处理一个客户端的请求，如果有一个客户端占用服务器不放时，其它的客户机连接请求都得不到及时的响应。因此，TCP服务器一般很少用循环服务器模型的。
2、TCP并发服务器：并发服务器的思想是每一个客户端的请求并不由服务器的主进程直接处理，而是服务器主进程创建一个子进程来处理。
    创建TCP并发服务器的算法如下：
    socket(……)； //创建一个TCP套接字
    bind(……)；    //邦定公认的端口号
    listen(……）；//倾听客户端连接
    while(1）       //开始循环接收客户端的接收
   {
                accept(……)；//接收一个客户端的连接
                if(fork(……)==0)  //创建子进程
                {                    
                         while(1)
                             {             //子进程处理某个客户端的连接
                                   read(……）；
                                   process(……);
                                   write(……);
                              }
                             close(……);  //关闭子进程处理的客户端连接
                              exit(……) ；//终止该子进程
                    }
                 close（……);           //父进程关闭连接套接字描述符，准备接收下一个客户端连接
       }
TCP并发服务器可以解决TCP循环服务器客户端独占服务器的情况。但同时也带来了一个不小的问题，即响应客户机的请求，服务器要创建子进程来处理，而创建子进程是一种非常消耗资源的操作。
3、UDP循环服务器：UDP服务器每次从套接字上读取一个客户端的数据报请求，处理接收到的UDP数据报，然后将结果返回给客户机。
    创建UDP循环服务器的算法如下：
    socket(……);  //创建一个数据报类型的套接字
    bind(……);     //邦定公认的短口号
     while(1)        //开始接收客户端的连接
    {                   //接收和处理客户端的UDP数据报
                   recvfrom(……);
                   process(……);
                   sendto(……);
                  //准备接收下一个客户机的数据报
        }
因为UDP是非面向连接的，没有一个客户端可以独占服务器。只要处理过程不是死循环，服务器对于每一个客户机的请求总是能够处理的。
UDP循环服务器在数据报流量过大时由于处理任务繁重可能造成客户技数据报丢失，但是因为UDP协议本身不保证数据报可靠到达，所以UDP协议是尤许丢失数据报的。
鉴于以上两点，一般的UDP服务器采用循环方式
4、UDP并发服务器
把并发的概念应用UDP就得到了并发UDP服务器，和并发TCP服务器模型一样是创建子进程来处理的。
创建UDP并发服务器的算法如下：
     socket(……);  //创建一个数据报类型的套接字
     bind(……);     //邦定公认的短口号
     while(1)        //开始接收客户端的连接
    {                   //接收和处理客户端的UDP数据报
                   recvfrom(……);
                  if(fork(……)==0)  //创建子进程
                  {
                         process(……);
                         sendto(……);
                   }
         }
除非服务器在处理客户端的请求所用的时间比较长以外，人们实际上很少用这种UDP并发服务器模型的。
5、多路复用I/O并发服务器：创建子进程会带来系统资源的大量消耗，为了解决这个问题，采用多路复用I/O模型的并发服务器。采用select函数创建多路复用I/O模型的并发服务器的算法如下：
  初始化(socket,bind,listen);
  while(1)
  {
     设置监听读写文件描述符（FD_*）；
     调用select;
     如果是倾听套接字就绪，说明一个新的连接请求建立
     {
           建立连接（accept）；
           加入到监听文件描述符中去；
       }
     否则说明是一个已经连接过的描述符
       {
                 进行操作(read或者write);
       }
  }
多路复用I/O可以解决资源限制问题，此模型实际上是将UDP循环模型用在了TCP上面。这也会带了一些问题，如由于服务器依次处理客户的请求，所以可能导致友的客户会等待很久。



http://bbs.chinaitlab.com/dispbbs.asp?boardid=148&id=114926
阻塞  
　　阻塞，你也许早就听说了。"阻塞"是 "sleep" 的科技行话。你可能注意 到前面运行的 listener 程序，它在那里不停地运行，等待数据包的到来。 实际在运行的是它调用 recvfrom()，然后没有数据，因此 recvfrom() 说" 阻塞 (block)"，直到数据的到来。
很多函数都利用阻塞。accept() 阻塞，所有的 recv*() 函数阻塞。它们之所以能这样做是因为它们被允许这样做。当你第一次调用 socket() 建立套接字描述符的时候，内核就将它设置为阻塞。如果你不想套接字阻塞， 你就要调用函数 fcntl()：  
#include  
　　#include  
　　 .  
　　 .  
　　 sockfd = socket(AF_INET, SOCK_STREAM, 0);  
　　 fcntl(sockfd, F_SETFL, O_NONBLOCK);  
　　 .  
　　 .  
　　通过设置套接字为非阻塞，你能够有效地"询问"套接字以获得信息。如 果你尝试着从一个非阻塞的套接字读信息并且没有任何数据，它不允许阻 塞--它将返回 -1 并将 errno 设置为 EWOULDBLOCK。  
但是一般说来，这种询问不是个好主意。如果你让你的程序在忙等状 态查询套接字的数据，你将浪费大量的 CPU 时间。更好的解决之道是用 下一章讲的 select() 去查询是否有数据要读进来。
--------------------------------------------------------------------------------
select()--多路同步 I/O
　　虽然这个函数有点奇怪，但是它很有用。假设这样的情况：你是个服 务器，你一边在不停地从连接上读数据，一边在侦听连接上的信息。没问题，你可能会说，不就是一个 accept() 和两个 recv() 吗? 这么 容易吗，朋友? 如果你在调用 accept() 的时候阻塞呢? 你怎么能够同时接 受 recv() 数据? “用非阻塞的套接字啊！” 不行！你不想耗尽所有的 CPU 吧? 那么，该如何是好?
select() 让你可以同时监视多个套接字。如果你想知道的话，那么它就 会告诉你哪个套接字准备读，哪个又准备写，哪个套接字又发生了例外 (exception)。
闲话少说，下面是 select()：
#include  
　　#include  
　　#include  
int select(int numfds, fd_set *readfds, fd_set *writefds,fd_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 设置为你要等待的微秒数就可以了。是的，是微秒而不是毫秒。1,000微秒等于1毫秒，1,000 毫秒等于1秒。也就是说，1秒等于1,000,000微秒。为什么用符号 "usec" 呢? 字母 "u" 很象希腊字母 Mu，而 Mu 表示 "微" 的意思。当然，函数 返回的时候 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() 要讲的所有的东西。
WinSock I/O系列1：多路复用I/O支持多Client的实现及效率讨论     选择自 HuangRG 的 Blog  
关键字   多路复用I/O select效率 多客户端
出处   

1.       引言
多路复用I/O模型(select)是UNIX/LINUX用得的最多的一种I/O模型，在Windows下也
可做为一种同步I/O使用。本文给出该I/O模型处理多Client的简单（在主线程中）实现。
2.       关于select
select I/O模型是一种异步I/O模型，在单线程中Linux/WinNT默认支持64个客户端套
接字。这种I/O模型主要涉及以下几个函数及宏：
int select(…)、FD_ZERO、FD_SET、FD_ISSET以及FD_SETSIZE。
3.       用select开发一个Server
3.1 只支持单个Client
    // 相关初始化处理, 创建监听套接字
    listen(listensock,  5);
    clientsock  =  accept(listensock,  NULL,  NULL);
    for  (; ;)
    {
             FD_ZERO(&readfds);  
             FD_SET(clientsock, &readfds);
             nResult = select(
                     0,         // Windows中这个参数忽略，Linux中在此处为1
                     readfds,    // 可读套接字集合
                     ……
              )
             if   (nResult  = =  SOCKET_ERROR)
                    return –1;
             // 判断cliensock是否处于待读状态
             if  (FD_ISSET(clientsock,  &readfds))
            {
                              // 相关处理
            }
    }
其实Winsock中的WSAEventSelect模型是与之类似的。
3.2  在单线程中支持63个Client
   SOCKET clientsockarray[FD_SETSIZE – 1];   // FD_SETSIZE is 64
  // 相关初始化处理, 创建监听套接字
   
  listen(listensock, 5);
  // 初始化套接字数组
InitSock(clientsockarray);
  FD_ZERO(&readfds);
  FD_SET(listensock,  &readfds);
  for  (; ;)
{
nRet  = select(0,  &readfds,  NULL,  NULL,  NULL);
// 判断监听套接字是否可读
if  (FD_ISSET(listensock,  &readfds))
{
         clientsock = accept(listensock,  NULL,  NULL);
          // 将客户套接字放到套接字数组中
          if   (!InsertSock(clientsockarray, clientsock))
          {
                   printf("客户端超过了63个,此次连接被拒绝.\n");
                   closesocket(clientsock);
                   continue;
           }   
  }
   
  // 逐个处理处于待决状态的套接字
  for  (nIndex  =  0;  nIndex  
{
           if   (FD_ISSET(clientsockarray[nIndex],  &readfds))
           {
                     nRet  =  recv(clientsockarray[nIndex],  buff,  sizeof(buff),  0);
                     if  (nRet  = =  0  ||  nRet  = =  SOCKET_ERROR)
                     {
                                closesocket(clientsockarray[nIndex]);
                            clientsockarray[nIndex] = INVALID_SOCKET;
                            continue;       // 继续处理套接字句柄数组中的其它套接字
                     }
                     // 将接受到的数据进行处理,此处只将其输出
                     printf("%s\n", buff);
              }
       }

       // 初始化套接字集合
       FD_ZERO(&readfds);
       FD_SET(listensock, &readfds);
       // 将所有有效的套接字句柄加入到套接字句柄数组中
       for (nIndex = 0; nIndex
       {
if (clientsockarray[nIndex] != INVALID_SOCKET)
              FD_SET(clientsockarray[nIndex], &readfds);
       }
}

BOOL InsertSock(SOCKET* pSock,  SOCKET sock)
{
          for   (int  nIndex  =  0;  nIndex  
         {
                                     if   (pSock[nIndex]  = =  INVALID_SOCKET)
                  {
                          pSock[nIndex] = sock;
                          break;
                  }
          }

          if   (nIndex = = FD_SETSIZE – 1)
                 return FALSE;
      
          return TRUE;
}

       上面只是给简要的代码，有的辅助函数也没有给出。用select支持多Client是比较方便的，在一个线程中可支持63个；可以采用多线程支持更大数量的Client。
4.       效率的讨论
4.1  对套接字数组扫描的效率问题
    在上面的程序中，存在多处对套接字句柄的扫描处理，这个肯定会影响效率。不知道各位朋友是怎么处理这个问题的。
4.2 对客户端实时响应问题
上面的程序处理待决的套接字的时候，是逐个处理的，如果响应某个Client的时间长到一定程度的话，肯定会影响对其它客户端的响应。我的解决方法是当这个套接字处于可读的待决状态的话，产生一个子线程去处理------接收数据和处理数据。这样主线程继续自己的工作，其它Client可以得及时的响应；当然当有大量的Client请求时，对线程的控制会成为一个新问题。
在UNIX/LINUX下做一个支持大量Client的Server的话，本人还是最先选择select这种I/O模型，这是因为我还不知道LINUX还有哪些更好的I/O模型。WinNT的话，还有 CompletionPort和Overlapped，特别对于有大数据量传送，同时只有少量的Client时，Overlapped可以发挥相当大的作用。各位朋友请给出使用select的好方法。
  
[转帖]select()的作用
select()的作用应该是这样的：
1.由任务调用select()：
void myTask()
{
...
select(width, readFds, writeFds, exceptFds, timeout);
...
}
select()意思是说：若readFds集合中的任一个fd可读，或writeFds中的任一个fd可写，或exceptFds中的任一个fd出异常（目前VxWorks还不支持），或者timeout指定的时间超时，则select()返回；否则任务myTask()处于阻塞状态，直到上述的条件之一得到满足。
2. select()的伪代码“可能”类似于：
select()
{
// selWakeupNode结构可能是malloc得到的，或者静态的。不清楚。
selWakeupNode->taskId = taskIdSelf();
selWakeupNode->type = SELREAD;
for (each fd in readFds)
ioctl(fd, FIOSELECT, (int)selWakeupNode);
selWakeupNode->type = SELWRITE;
for (each fd in writeFds)
ioctl(fd, FIOSELECT, (int)selWakeupNode);
semTake(tcb->semSelect, timeout); // 进入阻塞状态；睡觉去了
selWakeupNode->type = SELREAD;
for (each fd in readFds)
ioctl(fd, FIOUNSELECT, selWakeupNode);
selWakeupNode->type = SELWRITE;
for (each fd in writeFds)
ioctl(fd, FIOUNSELECT, selWakeupNode);
}
FIOSELECT命令是告诉驱动程序：“我对您设备的可读/可写感兴趣，请在满足条件时务必通知我。别忘了，我叫selWakeupNode->taskId，我对selWakeupNode->type感兴趣。”
睡眠醒来后，任务又说：“ok，都别管我了。”
3. （2）中的每一个ioctl调用都会转换为和fd相关联的驱动程序的xxIoctl()的调用：
xxIoctl(pXxDev, function, arg)
{
switch (function) {
...
case FIOSELECT:
if ((retval = selNodeAdd(&pXxDev->selWakeupList, // 可能有多个任务要处理，用链表记住它们
(SEL_WAKEUP_NODE *)arg)) == OK) {
if ((selWakeupType(arg) == SELREAD && ‘当前可读’) ||
(selWakeupType(arg) == SELWRITE && ‘当前可写’))
selWakeup(arg); // 不用等待，醒来吧
}
return retval;
case FIOUNSELECT: // 该任务对我不感兴趣了...
return selNodeDelete(&pXxDev->selWakeupList,
(SEL_WAKUP_NODE *)arg);
...
}
}
字符设备（character device）驱动程序如果要支持select，必须处理FIOSELECT和FIOUNSELECT命令。一般在设备控制结构中定义select-wakeup-list，并在创建设备时初始化。
4. xx设备在发生中断时，ISR被调用：
xxInt(pXxDev)
{
// 读状态寄存器
if (''接收到数据'')// 可读
selWakeupAll(&pXxDev->selWakeupList, SELREAD);
if (''数据已发送'')// 可写
selWakeupAll(&pXxDev->selWakeupList, SELWRITE);
...
}
中断函数中根据情况唤醒所有等待可读/可写的任务。selWakeup()和selWakeupAll()都是I/O系统中的函数，看不到源码。猜想它们的伪码如下：
selWakeup(node)
{
semGive(node->taskId->semSelect); // 唤醒等待的任务
}
selWakeupAll(list, type)
{
for (each node in list)
if (node->type == type)
semGive(node->taskId->semSelect); // 唤醒等待的任务
}

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/63991/showart_509310.html