异步套接字基础：select函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET

　　select函数：

　　系统提供select函数来实现多路复用输入/输出模型。原型：

　　#include <sys/time.h>

　　#include <unistd.h>

　　int select(int nfds, fd_set *readset, fd_set *writeset,fd_set* exceptset, struct tim *timeout);

功能：

    测试指定的fd可读？可写？有异常条件待处理？
参数：
    nfds ：
    需要检查的文件描述符个数（即检查到fd_set的第几位），【数值应该比三组fd_set中所含的最大fd值更大，一般设为三组fd_set中所含的最大fd值加1（如在readset,writeset,exceptset中所含最大的fd为5，则nfds=6，因为fd是从0开始的）。设这个值是为提高效率，使函数不必检查fd_set的所有1024位（有些系统不止1024位有些则大于1024，根据系统而言，下面有具体描述）。】
    readset
    对应需要监测的一组可读文件描述符集合。
    writeset
  对应需要监测的一组可写文件描述符集合。
    exceptset

　对应需要监测的一组异常文件描述符的集合；【用来检查是否有异常条件出现的文件描述符。(注：错误不包括在异常条件之内)】

　　struct timeval结构：

　　struct timeval{

　　long tv_sec;//second

　　long tv_usec;//minisecond

　　}

　　timeout
    用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0。
    有三种可能：
      1.timeout=NULL（阻塞：select将一直被阻塞，直到某个文件描述符上发生了事件）
      2.timeout所指向的结构设为非零时间（等待固定时间：如果在指定的时间段里有事件发生或者时间耗尽，函数均返回）
      3.timeout所指向的结构，时间设为0（非阻塞：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生）

返回值：
返回对应位仍然为1的fd的总数。注：即发生事件的文件描述符个数，即发生的事件数。如果为负值：则select错误，如果为0，则表示等待超时或没有可读写或错误的文件。

　三组fd_set均只将那些可读，可写以及有异常条件待处理的fd位仍然为1。其余位置0，

　举个例子，比如recv(), 在没有数据到来调用它的时候,你的线程将被阻塞,如果数据一直不来,你的线程就要阻塞很久.这样显然不好. 所以采用select来查看套节字是否可读(也就是是否有数据读了)
步骤如下——

 1 socket   s;   
 2 .....   
 3 fd_set   set;   
 4 while(1)   
 5 {       
 6       FD_ZERO(&set);//将你的套接字集合清空   
 7       FD_SET(s,&set);//加入你感兴趣的套接字到集合,这里是一个读数据的套接字s   
 8       select(0,&set,NULL,NULL,NULL);//检查套接字是否可读, 很多情况下就是是否有数据(注意,只是说很多情况)，这里select是否出错没有写   
11       if(FD_ISSET(s,&set)   //检查s是否在这个集合里面【因为select将更新这个集合，把其中不可读的套接字去掉，只保留符合条件的套接字在这个集合里面   
12       {11
14               recv(s,...);   
15       }   
16       //do   something   here   
17 }

　　—————————————————————————————

　　4个重要宏定义FD_ZERO,FD_SET,FD_CLR,FD_ISSET:

　　FD_ZERO(fd_set *fdset)：将指定的文件描述符集清空，在对文件描述符集合进行设置前，必须对其进行初始化，如果不清空，由于在系统分配内存空间后，通常并不作清空处理，所以结果是不可知的。

　　FD_SET(fd_set *fdset)：用于在文件描述符集合中增加一个新的文件描述符。

　　FD_CLR(fd_set *fdset)：用于在文件描述符集合中删除一个文件描述符。

　　FD_ISSET(int fd,fd_set *fdset)：用于测试指定的文件描述符是否在该集合中。

　　如：

　　fd_set set;

　　FD_ZERO(&set); /* 将set清零 */

　　FD_SET(fd, &set); /* 将fd加入set */

　　FD_CLR(fd, &set); /* 将fd从set中清除 */

　　FD_ISSET(fd, &set); /* 如果fd在set中则真*/

　　在过去，一个fd_set通常只能包含少于等于32个文件描述符，因为fd_set其实只用了一个int的比特矢量来实现，在大多数情况下，检查fd_set能包括任意值的文件描述符是系统的责任，但确定你的fd_set到底能放多少有时你应该检查/修改宏FD_SETSIZE的值。*这个值是系统相关的*，同时检查你的系统中的select() 的man手册。有一些系统对多于1024个文件描述符的支持有问题。

　　——————————————————————————————————————————————————————————

　　多路复用的方式是真正实用的服务器程序，非多路复用的网络程序只能作为学习或着陪测的角色。

　　本文说下个人接触过的多路复用函数：select/poll/epoll/port。kqueue的*nix系统没接触过，估计熟悉了上面四种，kqueue也只是需要熟悉一下而已。

　　一、select模型

　　select原型： int select(int n ,fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

　　其中参数n表示监控的所有fd中最大值＋1。

　　和select模型紧密结合的四个宏，含义不解释了：

　　FD_CLR(int fd, fd_set *set);

　　FD_ISSET(int fd, fd_set *set);

　　FD_SET(int fd, fd_set *set);

　　FD_ZERO(fd_set *set);

　　理解select模型的关键在于理解fd_set，为说明方便，取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。

　　（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。

　　（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)

　　（3）若再加入fd＝2，fd=1,则set变为0001,0011

　　（4）执行select(6,&set,0,0,0)阻塞等待

　　（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。

　　基于上面的讨论，可以轻松得出select模型的特点：

　　（1)可监控的文件描述符个数取决与sizeof(fd_set)的值。我这边服务器上sizeof(fd_set)＝512，每bit表示一个文件描述符，则我服务器上支持的最大文件描述符是512*8=4096。据说可调，另有说虽然可调，但调整上限受于编译内核时的变量值。本人对调整fd_set的大小不太感兴趣，参考http://www.cppblog.com /CppExplore/archive/2008/03/21/45061.html中的模型2（1）可以有效突破select可监控的文件描述符上限。

　　（2）将fd加入select监控集的同时，还要再使用一个数据结构array保存放到select监控集中的fd，一是用于在select 返回后，array作为源数据和fd_set进行FD_ISSET判断。二是select返回后会把以前加入的但并无事件发生的fd清空，则每次开始 select前都要重新从array取得fd逐一加入（FD_ZERO最先），扫描array的同时取得fd最大值maxfd，用于select的第一个参数。

　　（3）可见select模型必须在select前循环array（加fd，取maxfd），select返回后循环array（FD_ISSET判断是否有事件发生）。

　　下面给一个伪码说明基本select模型的服务器模型：

 1 array[slect_len];
 2 nSock=0;
 3 array[nSock++]=listen_fd;(之前listen port已绑定并listen)
 4 maxfd=listen_fd;
 5 while{
 6 　　FD_ZERO(&set);
 7 　　foreach (fd in array)
 8 　　{
 9 　　　　fd大于maxfd，则maxfd=fd
10 　　　　FD_SET(fd,&set)
11 　　}
12 　　res=select(maxfd+1,&set,0,0,0)；
13 　　if(FD_ISSET(listen_fd,&set))
14 　　{
15 　　　　newfd=accept(listen_fd);
16 　　　　array[nsock++]=newfd;
17 　　　　if(--res<=0) continue
18 　　}
19 　　foreach 下标1开始 (fd in array)
20 　　{
21 　　　　if(FD_ISSET(fd,&tyle="COLOR: #ff0000">set))
22 　　　　执行读等相关操作
23 　　　　如果错误或者关闭，则要删除该fd，将array中相应位置和最后一个元素互换就好，nsock减一
24 　　　　if(--res<=0) continue
25 　　}
26 }

使用select函数的过程一般是：
先调用宏FD_ZERO将指定的fd_set清零，然后调用宏FD_SET将需要测试的fd加入fd_set，接着调用函数select测试fd_set中的所有fd，最后用宏FD_ISSET检查某个fd在函数select调用后，相应位是否仍然为1。

以下是一个测试单个文件描述字可读性的例子：

 1      int isready(int fd)
 2      {
 3          int rc;
 4          fd_set fds;
 5          struct tim tv;    
 6          FD_ZERO(&fds);
 7          FD_SET(fd,&fds);
 8          tv.tv_sec = tv.tv_usec = 0;    
 9          rc = select(fd+1, &fds, NULL, NULL, &tv);
10          if (rc < 0)   //error
11          return -1;    
12          return FD_ISSET(fd,&fds) ? 1 : 0;
13      }

　　下面还有一个复杂一些的应用：
//这段代码将指定测试Socket的描述字的可读可写性，因为Socket使用的也是fd

 1 uint32 SocketWait(TSocket *s,bool rd,bool wr,uint32 timems)    
 2 {
 3      fd_set rfds,wfds;
 4 #ifdef _WIN32
 5      TIM tv;
 6 #else
 7      struct tim tv;
 8 #endif    
 9      FD_ZERO(&rfds);
10      FD_ZERO(&wfds); 
11      if (rd)     //TRUE
12        FD_SET(*s,&rfds);   //添加要测试的描述字 
13      if (wr)     //FALSE
14        FD_SET(*s,&wfds); 
15      tv.tv_sec=timems/1000;     //second
16      tv.tv_usec=timems%1000;     //ms 
17      for (;;) //如果errno==EINTR，反复测试缓冲区的可读性
18           switch(select((*s)+1,&rfds,&wfds,NULL,
19               (timems==TIME_INFINITE?NULL:&tv))) //测试在规定的时间内套接口接收缓冲区中是否有数据可读
20          {                                              //0－－超时，-1－－出错
21          case 0:    
22               return 0; 
23          case (-1):   
24               if (SocketError()==EINTR)
25                    break;              
26               return 0; //有错但不是EINTR 
27           default:
28               if (FD_ISSET(*s,&rfds)) //如果s是fds中的一员返回非0，否则返回0
29                    return 1;
30               if (FD_ISSET(*s,&wfds))
31                    return 2;
32               return 0;
33          };
34 }

　其它例子（服务器端代码）：

　　引用

 1     #include <sys/types.h>
 2     #include <sys/socket.h>
 3     #include <stdio.h>
 4     #include <netinet/in.h>
 5     #include <sys/time.h>
 6     #include <sys/ioctl.h>
 7     #include <unistd.h>
 8     #include <stdlib.h>
 9 
10     int main()
11     {
12         int server_sockfd, client_sockfd;
13     　　int server_len, client_len;
14     　　struct sockaddr_in server_address;
15     　　struct sockaddr_in client_address;
16     　　int result;
17     　　fd_set readfds, testfds;
18     　　/*创建套接字:IPv4, tcp流套接字*/
19     　　server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
20     　　server_address.sin_family = AF_INET;
21     　　/*INADDR_ANY代表本机IP,htonl将其转换为网络字节顺序(大端模式)*/
22     　　server_address.sin_addr.s_addr = htonl(INADDR_ANY);
23     　　server_address.sin_port = htons(9734);
24     　　server_len = sizeof(server_address);
25     　　/*将端口与套接字绑定*/
26     　　bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
27     　　/*监听,可接受5个连接请求*/
28     　　listen(server_sockfd, 5);
29     　　FD_ZERO(&readfds);
30     　　FD_SET(server_sockfd, &readfds);
31     　　/*等待客户端请求*/
32     　　while(1) 
33         {
34         　　char ch;
35     　　　　int  fd;
36     　　　　int  nread;
37     　　　　testfds = readfds;
38     　　　　/*服务器在select后等待客户端的请求(服务器阻塞)*/
39     　　　　printf("server waiting/n");
40     　　　　result = select(FD_SETSIZE, &testfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0);
41     　　　　if (result < 1) {
42     　　　　　　perror("server");
43     　　　　　　exit(1);
44     　　　　}
45     　　　　/*轮询,实际程序不使用这种极度耗时的方法*/
46     　　　　for (fd = 0; fd < FD_SETSIZE; fd++) 
47             {
48     　　　　　　if (FD_ISSET(fd, &testfds)) 
49                 {
50         　　　　　　if (fd == server_sockfd) 
51                     {
52                         client_len = sizeof(client_address);
53                         /*接收客户端连接请求,并返回连接套接字用于收发数据*/
54     　　　　　　　　　　client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len); 
55     　　　　　　　　　　FD_SET(client_sockfd, &readfds);    /*需要监视发来请求的客户端*/
56     　　　　　　　　　　printf("adding client on fd %d/n", client_sockfd);
57     　　　　　　　　} 
58                     else 
59                     { /*客户端发生“状况”*/
60     　　　　　　　　　　ioctl(fd, FIONREAD, &nread);
61         　　　　　　　　if (nread == 0) 
62                         {
63         　　　　　　　　　　close(fd); /*读取不到任何内容,关闭与客户端的连接套接字*/
64         　　　　　　　　　　FD_CLR(fd, &readfds); /*清除客户端套接字描述符,不再对其"关注"*/
65     　　　　　　　　　　    printf("removing client on fd %d/n", fd);
66     　　　　　　　　    } 
67                         else 
68                         {
69     　　　　　　　　　　    read(fd, &ch, 1);
70     　　　　　　　　　　    sleep(5);
71     　　　　　　　　　　    printf("serving client on fd %d/n", fd);
72     　　　　　　　　　　    ch++;
73     　　　　　　　　　　    write(fd, &ch, 1);
74     　　　　　　　　    }
75     　　　　　　    }
76     　　　　    }
77     　　　　}
78     　　}
79 
80     }

　　例子2

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4 #include <errno.h>
  5 #include <string.h>
  6 #include <sys/types.h>
  7 #include <sys/socket.h>
  8 #include <netinet/in.h>
  9 #include <arpa/inet.h>
 10 #define MYPORT 1234    // the port users will be connecting to
 11 #define BACKLOG 5     // how many pending connections queue will hold
 12 #define BUF_SIZE 200
 13 
 14 int fd_A[BACKLOG];    // accepted connection fd
 15 int conn_amount;    // current connection amount
 16 void showclient()
 17 {
 18     int i;
 19     printf("client amount: %d/n", conn_amount);
 20 　　for (i = 0; i < BACKLOG; i++)
 21 　　{
 22     　　printf("[%d]:%d  ", i, fd_A[i]);
 23 　　}
 24 　　printf("/n/n");
 25 }
 26 
 27 int main(void)
 28 {
 29     int sock_fd, new_fd;  // listen on sock_fd, new connection on new_fd
 30 　　struct sockaddr_in server_addr;    // server address information
 31 　　struct sockaddr_in client_addr; // connector's address information
 32 　　socklen_t sin_size;
 33 　　int yes = 1;
 34 　　char buf[BUF_SIZE];
 35 　　int ret;
 36 　　int i;
 37 　　if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
 38 　　{
 39     　　perror("socket");
 40     　　exit(1);
 41 　　}
 42 　　if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
 43 　　{
 44     　　perror("setsockopt");
 45     　　exit(1);
 46 　　}
 47 　　server_addr.sin_family = AF_INET;         // host byte order
 48 　　server_addr.sin_port = htons(MYPORT);     // short, network byte order
 49 　　server_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
 50 　　memset(server_addr.sin_zero, '/0', sizeof(server_addr.sin_zero));
 51 　　if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
 52 　　{
 53     　　perror("bind");
 54     　　exit(1);
 55 　　}
 56 　　if (listen(sock_fd, BACKLOG) == -1)
 57 　　{
 58     　　perror("listen");
 59     　　exit(1);
 60 　　}
 61 　　printf("listen port %d/n", MYPORT);
 62 　　fd_set fdsr;
 63 　　int maxsock;
 64 　　struct timeval tv;
 65 　　conn_amount = 0;
 66 　　sin_size = sizeof(client_addr);
 67 　　maxsock = sock_fd;
 68 　　while (1)
 69 　　{
 70     　　// initialize file descriptor set
 71     　　FD_ZERO(&fdsr);
 72     　　FD_SET(sock_fd, &fdsr);
 73     　　// timeout setting
 74     　　tv.tv_sec = 30;
 75     　　tv.tv_usec = 0;
 76     　　// add active connection to fd set
 77     　　for (i = 0; i < BACKLOG; i++)
 78     　　{
 79         　　if (fd_A[i] != 0)
 80         　　{
 81             　　FD_SET(fd_A[i], &fdsr);
 82         　　}
 83     　　}
 84     　　ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);
 85     　　if (ret < 0)
 86     　　{
 87     　　    perror("select");
 88     　　    break;
 89     　　} 
 90         else if (ret == 0)
 91     　　{
 92         　　printf("timeout/n");
 93         　　continue;
 94     　　}
 95     　　// check every fd in the set
 96     　　for (i = 0; i < conn_amount; i++)
 97     　　{
 98         　　if (FD_ISSET(fd_A[i], &fdsr))
 99         　　{
100             　　ret = recv(fd_A[i], buf, sizeof(buf), 0);
101             　　if (ret <= 0)
102             　　{        // client close
103                 　　printf("client[%d] close/n", i);
104                 　　close(fd_A[i]);
105                 　　FD_CLR(fd_A[i], &fdsr);
106                 　　fd_A[i] = 0;
107             　　}
108             　　else
109             　　{        // receive data
110                 　　if (ret < BUF_SIZE)
111                     　　memset(&buf[ret], '/0', 1);
112                 　　printf("client[%d] send:%s/n", i, buf);
113 
114             　　}
115         　　}
116     　　}
117 
118     　　// check whether a new connection comes
119     　　if (FD_ISSET(sock_fd, &fdsr))
120     　　{
121         　　new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);
122             if (new_fd <= 0)
123         　　{
124             　　perror("accept");
125             　　continue;
126         　　}
127         　　// add to fd queue
128         　　if (conn_amount < BACKLOG)
129         　　{
130             　　fd_A[conn_amount++] = new_fd;
131             　　printf("new connection client[%d] %s:%d/n", conn_amount,
132             　　inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
133             　　if (new_fd > maxsock)
134             　　maxsock = new_fd;
135         　　}
136         　　else
137         　　{
138             　　printf("max connections arrive, exit/n");
139             　　send(new_fd, "bye", 4, 0);
140             　　close(new_fd);
141             　　break;
142         　　}
143     　　}
144     　　showclient();
145 　　}
146 
147 　　// close other connections
148 　　for (i = 0; i < BACKLOG; i++)
149 　　{
150     　　if (fd_A[i] != 0)
151     　　{
152         　　close(fd_A[i]);
153     　　}
154 　　}
155 　　exit(0);
156 
157 }
158 
159

转载声明： 本文转自 http://doc.chinaunix.net/linux/201007/713872.shtml

　　　　　　　　　　http://blog.csdn.net/sunboy_2050/article/details/5971616

　　　　　　　　　　http://blog.csdn.net/cstarbl/article/details/7645298

相关阅读:
tomcat 添加用户名和密码
 linux系统下获取cpu、硬盘、内存使用率
 snmp 企业对应的mib编号
 String加密解密 2017.07.26
Mongo日期
 linux sed 批量替换多个文件中的字符串
 Python和giL的关系
 vim
乌班图
 Python
原文地址：https://www.cnblogs.com/liushui-sky/p/5569029.html