Linux:C/Socket多路复用select

作一个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[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上面.这也就带来了一些问题.如由于服务器依次处理客户的请求,所以可能会导致有的客户 会等待很久.

9.5 并发服务器:UDP服务器
人们把并发的概念用于UDP就得到了并发UDP服务器模型.并发UDP服务器模型其实是简单的.和并发的TCP服务器模型一样是创建一个子进程来处理的 算法和并发的TCP模型一样.

除非服务器在处理客户端的请求所用的时间比较长以外,人们实际上很少用这种模型.

9.6 一个并发TCP服务器实例

#include
#include
#include
#include
#include
#defineMY_PORT        8888

int main(int argc ,char **argv)
{
 int listen_fd,accept_fd;
 structsockaddr_in    client_addr;
 int n;
 
 if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)
  {
       printf("Socket Error:%s\n\a",strerror(errno));
       exit(1);
  }
 
 bzero(&client_addr,sizeof(structsockaddr_in));
 client_addr.sin_family=AF_INET;
 client_addr.sin_port=htons(MY_PORT);
 client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
 n=1;
 
 setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int));
 if(bind(listen_fd,(struct sockaddr*)&client_addr,sizeof(client_addr))<0)
  {
       printf("Bind Error:%s\n\a",strerror(errno));
       exit(1);
  }
  listen(listen_fd,5);
  while(1)
  {
  accept_fd=accept(listen_fd,NULL,NULL);
  if((accept_fd<0)&&(errno==EINTR))
         continue;
   elseif(accept_fd<0)
    {
       printf("Accept Error:%s\n\a",strerror(errno));
       continue;
    }
  if((n=fork())==0)
   {
       
       char buffer[1024];

       close(listen_fd);
       n=read(accept_fd,buffer,1024);
       write(accept_fd,buffer,n);
       close(accept_fd);
       exit(0);
   }
   elseif(n<0)
       printf("Fork Error:%s\n\a",strerror(errno));
   close(accept_fd);
  }
}

 

 

 

 

 

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上面。这也会带了一些问题，如由于服务器依次处理客户的请求，所以可能导致友的客户会等待很久。
 

阻塞
　 　阻塞，你也许早就听说了。"阻塞"是"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是否在集合中
最 后，是有点古怪的数据结构 structtimeval。有时你可不想永远等待别人发送数据过来。也许什么事情都没有发生的时候你也想每隔96秒在终端上打印字符串"StillGoing..."。这个数据结构允许你设定一个时间，如果 时间到了，而 select()还没有找到一个准备好的文件描述符，它将返回让你继续处理。
数据结构 struct timeval 是这样的：
struct timeval {
　　 int tv_sec;
　　 int tv_usec;
　　 };
只 要将 tv_sec 设置为你要等待的秒数，将 tv_usec设置为你要等待的微秒数就可以了。是的，是微秒而不是毫秒。1,000微秒等于1毫秒，1,000毫秒等于1秒。也就是说，1秒等于1,000,000微秒。为什么用符号"usec" 呢? 字母"u" 很象希腊字母 Mu，而 Mu表示"微" 的意思。当然，函数返回的时候 timeout 可能是剩余的时间，之所以是可能，是因为它依赖于你的 Unix操作系统。
哈！我们现在有一个微秒级的定时器！别计算了，标准的 Unix 系统的时间片是100毫秒，所以无论你如何设置你的数据结构 structtimeval，你都要等待那么长的时间。
还 有一些有趣的事情：如果你设置数据结构 struct timeval 中的数据为 0，select()将立即超时，这样就可以有效地轮询集合中的所有的文件描述符。如果你将参数 timeout 赋值为NULL，那么将永远不会发生超时，即一直等到第一个文件描述符就绪。最后，如果你不是很关心等待多长时间，那么就把它赋为 NULL吧。
下面的代码演示了在标准输入上等待 2.5 秒：
#include
　　#include
　　#include
#define STDIN 0
main()
　　 {
　　struct timeval tv;
　　fd_set readfds;
tv.tv_sec = 2;
　　tv.tv_usec = 500000;
FD_ZERO(&readfds);
　　FD_SET(STDIN,&readfds);

　　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() 要讲的所有的东西。

 

http://www.pcdog.com/p/html/2004123/31220042887_1.htm
深入UNIX编程:一个简单聊天室的两种实现 (fcntl 和 select)

--------------------------------------------------------------------------------
 
 
http://www.pcdog.com 2004-12-3互联网
 
　　      
     在互联网相当普及的今天，在互联网上聊天对很多“网虫”来说已经是家常便饭了。聊天室程序可以说是网上最简单的多点通信程序。聊天室的实现方法有很多，但都是利用所谓的“多用户空间”来对信息进行交换，具有典型的多路I/O的
架 构。一个简单的聊天室,从程序员的观点来看就是在多个I/O端点之间实现多对多的通信。其架构如图一所示。这样的实现在用户的眼里就是聊天室内任何一个人输入一段字符之后,其他用户都可以得到这一句话。这种“多用户空间”的架构在其他多点通信程序中应用的非常广泛，其核心就是多路I/O通信。多路I/O通信又被称为I/O多路复用（I/O Multiplexing）一般被使用在以下的场合：
 
     客户程序需要同时处理交互式的输入和同服务器之间的网络连接时需要处理I/O多路复用问题；
     客户端需要同时对多个网络连接作出反应（这种情况很少见）；
     TCP服务器需要同时处理处于监听状态和多个连接状态的socket；
     服务器需要处理多个网络协议的socket;
     服务器需要同时处理不同的网络服务和协议。

     聊天室所需要面对的情况正是第一和第三两种情况。我们将通过在TCP/IP协议之上建立一个功能简单的聊天室让大家更加了解多路I/O以及它的实现方法。我们要讨论的聊天室功能非常简单, 感兴趣的朋友可以将其功能扩展, 发展成一个功能比较完整的聊天室, 如加上用户认证, 用户昵称,秘密信息, semote 等功能. 首先它是一个 client/server 结构的程序, 首先启动 server, 然后用户使用client 进行连接. client/server 结构的优点是速度快, 缺点是当 server 进行更新时, client也必需更新.
　
网络初始化
　
     首先是初始化 server, 使server 进入监听状态: (为了简洁起见,以下引用的程序与实际程序略有出入, 下同)
sockfd = socket( AF_INET,SOCK_STREAM, 0);
// 首先建立一个 socket, 族为 AF_INET, 类型为 SOCK_STREAM.
// AF_INET = ARPA Internet protocols 即使用 TCP/IP 协议族
// SOCK_STREAM 类型提供了顺序的, 可靠的, 基于字节流的全双工连接.
// 由于该协议族中只有一个协议, 因此第三个参数为 0
　
bind( sockfd, ( struct sockaddr *)&serv_addr,sizeof( serv_addr));
// 再将这个 socket 与某个地址进行绑定.
// serv_addr 包括 sin_family = AF_INET 协议族同 socket
// sin_addr.s_addr = htonl( INADDR_ANY) server 所接受的所有其他
// 地址请求建立的连接.
// sin_port = htons( SERV_TCP_PORT) server 所监听的端口
// 在本程序中, server 的 IP和监听的端口都存放在 config 文件中.

listen( sockfd, MAX_CLIENT);
// 地址绑定之后, server 进入监听状态.
// MAX_CLIENT 是可以同时建立连接的 client 总数.
server 进入 listen 状态后, 等待 client 建立连接。

Client端要建立连接首先也需要初始化连接：
sockfd = socket( AF_INET,SOCK_STREAM,0));
// 同样的, client 也先建立一个 socket, 其参数与 server 相同.

connect( sockfd, ( struct sockaddr *)&serv_addr,sizeof( serv_addr));
// client 使用 connect 建立一个连接.
// serv_addr 中的变量分别设置为:
// sin_family = AF_INET 协议族同 socket
// sin_addr.s_addr = inet_addr( SERV_HOST_ADDR) 地址为 server
// 所在的计算机的地址.
// sin_port = htons( SERV_TCP_PORT) 端口为 server 监听的端口.

当 client 建立新连接的请求被送到Server端时, server 使用 accept 来接受该连接:
accept( sockfd, (structsockaddr*)&cli_addr,&cli_len);
// 在函数返回时, cli_addr 中保留的是该连接对方的信息
// 包括对方的 IP 地址和对方使用的端口.
// accept 返回一个新的文件描述符.

     在 server 进入 listen 状态之后,由于已有多个用户在线，所以程序需要同时对这些用户进行操作，并在它们之间实现信息交换。这在实现上称为I/O多路复用技术。多路复用一般有以下几种方法：

     非阻塞通信方法：将文件管道通过fcntl()设为非阻塞通信方式，每隔一端时间对他们实行一次轮询，以判断是否可以进行读写操作。这种方式的缺点是费用太高，大部分资源浪费在轮询上。

     子进程方法：应用多个子进程，每一个对一个单工阻塞方式通信。所有子进程通过IPC和父进程进行通信。父进程掌管所有信息。这种方式的缺点是实现复杂，而且由于IPC在各个操作系统平台上并不完全一致，会导致可移植性降低。

     信号驱动（SIGIO）的异步I/O方法：首先，异步I/O是基于信号机制的，并不可靠。其次单一的信号不足以提供更多的信息来源。还是需要辅助以其他的手段，实现上有很高的难度。

     select()方法：在BSD中提供了一种可以对多路I/O进行阻塞式查询的方法——select()。它提供同时对多个I/O描述符进行阻塞式查询的方法，利用它，我们可以很方便的实现多路复用。根据统一UNIX规范的协议,POSIX也采用了这种方法，因此，我们可以在大多数操作系统中使用select方法。

     使用专门的I/O多路复用器：在“UNIX? SYSTEM V Programmer&apossGuide: STREAMS”一书中详细的说明了构造和使用多路复用器的方法。这里就不再详述了。
　
我们下面分别讨论多路I/O的两种实现方法:

1. 非阻塞通信方法

     对一个文件描述符指定的文件或设备, 有两种工作方式: 阻塞与非阻塞。所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时,如果当时没有东西可读,或者暂时不可写, 程序就进入等待状态, 直到有东西可读或者可写为止。而对于非阻塞状态, 如果没有东西可读,或者不可写, 读写函数马上返回, 而不会等待。缺省情况下, 文件描述符处于阻塞状态。在实现聊天室时, server需要轮流查询与各client 建立的 socket, 一旦可读就将该 socket 中的字符读出来并向所有其他client发送。并且, server 还要随时查看是否有新的 client 试图建立连接,这样, 如果 server 在任何一个地方阻塞了,其他 client 发送的内容就会受到影响,得不到服务器的及时响应。新 client试图建立连接也会受到影响。所以我们在这里不能使用缺省的阻塞的文件工作方式，而需要将文件的工作方式变成非阻塞方式。在UNIX下，函数fcntl()可以用来改变文件I/O操作的工作方式，函数描述如下：

fcntl( sockfd, F_SETFL, O_NONBLOCK);
// sockfd 是要改变状态的文件描述符.
// F_SETFL 表明要改变文件描述符的状态
// O_NONBLOCK 表示将文件描述符变为非阻塞的.

为了节省篇幅我们使用自然语言描述聊天室 server :
while ( 1)
{
     if 有新连接 then 建立并记录该新连接;
     for ( 所有的有效连接)
           begin
                 if 该连接中有字符可读 then
                       begin
                             读入字符串；
                       for ( 所有其他的有效连接)
                             begin
                                   将该字符串发送给该连接;
                             end;
                       end;
           end;
     end.

     由于判断是否有新连接, 是否可读都是非阻塞的, 因此每次判断,不管有还是没有, 都会马上返回. 这样,任何一个 client 向server 发送字符或者试图建立新连接, 都不会对其他 client 的活动造成影响。
对 client 而言, 建立连接之后, 只需要处理两个文件描述符, 一个是建立了连接的 socket 描述符, 另一个是标准输入.和 server 一样, 如果使用阻塞方式的话, 很容易因为其中一个暂时没有输入而影响另外一个的读入.. 因此将它们都变成非阻塞的,然后client 进行如下动作:

while ( 不想退出)
     begin
     if ( 与 server 的连接有字符可读)
           begin
           从该连接读入, 并输出到标准输出上去.
           End;
     if ( 标准输入可读)
           Begin
           从标准输入读入, 并输出到与 server 的连接中去.
           End;
     End.

上面的读写分别调用这样两个函数:
read( userfd[i], line, MAX_LINE);
// userfd[i] 是指第 i 个 client 连接的文件描述符.
// line 是指读出的字符存放的位置.
// MAX_LINE 是一次最多读出的字符数.
// 返回值是实际读出的字符数.

write( userfd[j], line, strlen( line));
// userfd[j] 是第 j 个 client 的文件描述符.
// line 是要发送的字符串.
// strlen( line) 是要发送的字符串长度.

分 析上面的程序可以知道, 不管是 server 还是 client, 它们都不停的轮流查询各个文件描述符,一旦可读就读入并进行处理. 这样的程序, 不停的在执行, 只要有CPU 资源, 就不会放过。因此对系统资源的消耗非常大。server或者 client 单独执行时, CPU 资源的 98% 左右都被其占用。极大的消耗了系统资源。

select 方法

     因此，虽然我们不希望在某一个用户没有反应时阻塞其他的用户，但我们却应该在没有任何用户有反应的情况之下停止程序的运行，让出抢占的系统资源，进入阻塞状态。有没有这种方法呢？现在的UNIX系统中都提供了select方法，具体实现方式如下：
 
     select 方法中, 所有文件描述符都是阻塞的. 使用 select 判断一组文件描述符中是否有一个可读(写), 如果没有就阻塞,直到有一个的时候就被唤醒. 我们先看比较简单的 client 的实现:

由于 client 只需要处理两个文件描述符, 因此, 需要判断是否有可读写的文件描述符只需要加入两项:
FD_ZERO( sockset);
// 将 sockset 清空
FD_SET( sockfd, sockset);
// 把 sockfd 加入到 sockset 集合中
FD_SET( 0, sockset);
// 把 0 (标准输入) 加入到 sockset 集合中
 
然后 client 的处理如下:

while ( 不想退出)
{
     select( sockfd+1,&sockset, NULL, NULL, NULL);
     // 此时该函数将阻塞直到标准输入或者 sockfd 中有一个可读为止
     // 第一个参数是 0 和 sockfd 中的最大值加一
     // 第二个参数是 读集, 也就是 sockset
     // 第三, 四个参数是写集和异常集, 在本程序中都为空
     // 第五个参数是超时时间, 即在指定时间内仍没有可读, 则出错
     // 并返回. 当这个参数为NULL 时, 超时时间被设置为无限长.
     // 当 select 因为可读返回时, sockset 中包含的只是可读的
     // 那些文件描述符.

     if ( FD_ISSET( sockfd,&sockset))
     {
           // FD_ISSET 这个宏判断 sockfd 是否属于可读的文件描述符
           从 sockfd 中读入, 输出到标准输出上去.
     }
     if ( FD_ISSET( 0,&sockset))
     {
           // FD_ISSET 这个宏判断 sockfd 是否属于可读的文件描述符
           从标准输入读入, 输出到 sockfd 中去.
     }
     重新设置 sockset. (即将 sockset 清空, 并将 sockfd 和 0 加入)
}

下面看 server 的情况:

设置 sockset 如下:
FD_ZERO( sockset);
FD_SET( sockfd, sockset);
for ( 所有有效连接)
FD_SET( userfd[i], sockset);
}
maxfd = 最大的文件描述符号 + 1;

server 处理如下:
while ( 1)
{
     select( maxfd,&sockset, NULL, NULL, NULL);
     if ( FD_ISSET( sockfd,&sockset))
     {
           // 有新连接
           建立新连接, 并将该连接描述符加入到 sockset 中去了.
     }
     for ( 所有有效连接)
     {
           if ( FD_ISSET ( userfd[i],&sockset))
           {
                 // 该连接中有字符可读
                 从该连接中读入字符, 并发送到其他有效连接中去.
           }
     }
     重新设置 sockset;
}

性能比较

     由于采用 select 机制, 因此当没有字符可读时, 程序处于阻塞状态,最小程度的占用CPU 资源, 在同一台机器上执行一个server 和若干个client 时, 系统负载只有 0.1 左右, 而采用原来的非阻塞通信方法, 只运行一个 server,系统负载就可以达到 1.5 左右. 因此我们推荐使用 select.

 

WinSock I/O系列1：多路复用I/O支持多Client的实现及效率讨论 
关键字   多路复用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

   SOCKETclientsockarray[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 < FD_SETSIZE  - 1;  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< FD_SETSIZE - 1;nIndex++)

      {

if (clientsockarray[nIndex] != INVALID_SOCKET)

             FD_SET(clientsockarray[nIndex],&readfds);

      }

}

 

BOOL InsertSock(SOCKET* pSock,  SOCKETsock)

{

         for   (int nIndex  =  0; nIndex <  FD_SETSIZE –1;  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  对套接字数组扫描的效率问题

   在上面的程序中，存在多处对套接字句柄的扫描处理，这个肯定会影响效率。不知道各位朋友是怎么处理这个问题的。