socket多路复用的客户/服务器模型

前面一篇介绍了服务器端使用多线程的方式来处理多个客户端的请求的，但是当客户端数量增多时线程数量会急剧增加，导致消耗大量的资源。

于是就引出了服务器端的一种新的模型。

1. 阻塞与非阻塞

首先介绍几个基本的概念。

阻塞方式（ block ），顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，假如事件没有发生，进程或线程就被阻塞，函数不能立即返回。

非阻塞方式（ non-block ），就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，假如事件发生则和阻塞方式相同，若事件没有发生则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高。

套接字相关函数默认时采用阻塞方式操作，而大多数情况下，程序不仅仅只拥有一个套接字。当进程以阻塞方式操作其中之一时，必将导致不能使用其他的套接字。如果希望这些套接字同时工作，就必须设计并发的套接字程序，即在一个套接字读写的同时保证另一个套接字也能正常地操作。

多路复用函数 select 把一些文件描述符集合在一起，如果某个文件描述符的状态发生变化，比如进入“写就绪”或者“读就绪”状态，函数 select 会立即返回，并且通知进程读取或写入数据；如果没有 I/O 到达，进程将进入阻塞，直到函数 select 超时退出为止。

套接字也是文件，函数 select 也支持套接字描述符，并且可以应用在 TCP 协议和 UDP 协议的套接字中。利用多路复用，进程就可以同时监控多个套接字信息，在多个套接字上并发地执行操作。

2.select介绍

select的大概思想：将多个套接字放在一个集合里，然后统一检查这些套接字的状态（可读、可写、异常等），调用select后，会更新这些套接字的状态，然后做判断，如果套接字可读，就执行read操作。这样就巧妙地避免了阻塞，达到同时处理多个连接的目的。当然如果没有事件发生，select会一直阻塞，如果不想一直让它等待，想去处理其它事情，可以设置一个最大的等待时间。

[cpp] view plaincopy

1. int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout);  
2.    
3. /*参数列表 
4. int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。  
5. 　　 
6. fd_set *readfds是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，如果这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读，如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。  
7. 　　 
8. fd_set *writefds是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的写变化的，即我们关心是否可以向这些文件中写入数据了，如果这个集合中有一个文件可写，select就会返回一个大于0的值，表示有文件可写，如果没有可写的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的写变化。  
9. 　　 
10. fd_set *errorfds同上面两个参数的意图，用来监视文件错误异常。  
11. 　　 
12. struct timeval* timeout是select的超时时间，这个参数至关重要，它可以使select处于三种状态： 
13. 第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止； 
14. 第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值； 
15. 第三，timeout的值大于0，这就是等待的超时时间，即 select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。 
16. */  
17.   
18. /* 
19. 返回值：  
20.  
21.  
22. 负值：select错误 
23.  
24. 正值：某些文件可读写或出错 
25.  
26. 0：等待超时，没有可读写或错误的文件 
27. */  

上面有两个结构体。

第一， struct timeval 代表时间值

[cpp] view plaincopy

1. struct timeval{  
2.   
3.       long tv_sec;/* 秒 */  
4.   
5.       long tv_usec;/* 毫秒 */  
6.   
7. };  

第二， struct fd_set 能够理解为文件描述符的集合

[cpp] view plaincopy

1. #ifndef FD_SETSIZE  
2. #define FD_SETSIZE      64  
3. #endif /* FD_SETSIZE */  
4.   
5. typedef struct fd_set {  
6.         u_int fd_count;               /* how many are SET? */  
7.         SOCKET  fd_array[FD_SETSIZE];   /* an array of SOCKETs */  
8. } fd_set;  

fd_set 集合能够通过一些宏由人为来操作，比如清空集合 FD_ZERO(fd_set *) ，将一个给定的文件描述符加入集合之中 FD_SET(int ,fd_set*) ，将一个给定的文件描述符从集合中删除 FD_CLR(int,fd_set*)，检查集合中指定的文件描述符是否能够读写 FD_ISSET(int ,fd_set* ) 。

3.操作fd_set的宏

下面是这些宏的详细描述：

1. FD_ZERO(fd_set * set)，是把集合清空（初始化为0，确切的说，是把集合中的元素个数初始化为0，并不修改描述符数组).使用集合前，必须用FD_ZERO初始化，否则集合在栈上作为自动变量分配时，fd_set分配的将是随机值，导致不可预测的问题。
2. FD_SET(int s,fd_set * set)，向集合中加入一个套接口描述符（如果该套接口描述符s没在集合中，并且数组中已经设置的个数小于最大个数时，就把该描述符加入到集合中，集合元素个数加1）。这里是将s的值直接放入数组中。
3. FD_ISSET(int s,fd_set * set)，检查描述符是否在集合中，如果在集合中返回非0值，否则返回0. 它的宏定义并没有给出具体实现，但实现的思路很简单，就是搜索集合，判断套接字s是否在数组中。
4. FD_CLR(int s,fd_set * set)，从集合中移出一个套接口描述符（比如一个套接字连接中断后，就应该移除它）。实现思路是，在数组集合中找到对应的描述符，然后把后面的描述依次前移一个位置，最后把描述符的个数减1。

下面是使用这些宏的基本方式。

1. 调用FD_ZERO来初始化fd_set；
2. 调用FD_SET将感兴趣的套接字描述符加入fd_set集合中（每次循环都要重新加入，因为select更新后，会将一些没有满足条件的套接字移除队列）；
3. 设置等待时间后，调用select函数--更新套接字的状态；
4. 调用FD_ISSET，来判断套接字是否有相应状态，然后做相应操作，比如，如果套接字可读，就调用recv函数去接收数据。

4.自定义管理套接字的集合类SocketList

从上面可以看出，我们需要维护一个套接字集合，这个套接字的集合里存放的是和服务器建立连接的套接字，服务器每次循环调用select()时首先需要使用FD_ZERO宏来初始化fd_set对象，然后调用FD_SET将我们维护的这个套接字集合中的套接字加入fd_set这个集合中，然后就可以调用select函数了，调用完select函数后，再次遍历我们维护的这个套接字集合，通过FD_ISSET宏来判断这个套接字是否是我们需要进行处理的，如果是需要进行处理的，那么就对它进行处理。

所以现在这里的关键就是要维护一个套接字的集合，我把它定义为SocketList这个类，下面是我实现的C++类。这个套接字的集合类可以很方便地实现下面的功能：

1. 添加socket
2. 删除socket
3. 将前类中的所有感兴趣的socket加入到fd_set中

5.服务器端的实现

仍然是在原来服务端的第6步进行更改，但是在这之前启动了一个新的线程workThread，并且服务端也只需要启动一个这样的线程用来访问SocketList的对象。此时第6步就只需要将当前建立的socket添加到SocketList这个对象中。在workThread这个线程中访问SocketList的对象，在这个线程中调用select()函数即可。

服务端代码：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <WinSock2.h>  
4. #include <iostream>  
5.   
6. #pragma comment(lib, "ws2_32.lib")  
7.   
8.   
9. using namespace std;  
10.   
11. #define  PORT 6000  
12. //#define  IP_ADDRESS "10.11.163.113"  //表示服务器端的地址  
13. #define  IP_ADDRESS "127.0.0.1"  //直接使用本机地址  
14.   
15. class SocketList  
16. {  
17.     private:  
18.     int num;//记录socket的真实数目  
19.     SOCKET socketArray[FD_SETSIZE];//存放socket的数组  
20.   
21.     public:  
22.     SOCKET getSocket(int i)  
23.     {  
24.         return socketArray[i];  
25.     }  
26.   
27.     //构造函数中对两个成员变量进行初始化  
28.     SocketList()  
29.     {  
30.         num=0;  
31.         for (int i=0;i<FD_SETSIZE;i++)  
32.         {  
33.             //因为socket的值是一个非负整数值，所以可以将socketArray初始化为0，让它来表示数组中的这一个元素有没有被使用  
34.             socketArray[i]=0;  
35.         }  
36.     }  
37.   
38.     //往socketArray中添加一个socket  
39.     void insertSocket(SOCKET s)  
40.     {  
41.         for (int i=0;i<FD_SETSIZE;i++)  
42.         {  
43.             //如果某一个socketArray[i]为0，表示哪一个位可以放入socket  
44.             if (socketArray[i]==0)  
45.             {  
46.                 socketArray[i]=s;  
47.                 num++;  
48.                 break;//这里一定要加上break，不然一个socket会放在socketArray的多个位置上  
49.             }  
50.         }  
51.     }  
52.   
53.     //从socketArray中删除一个socket  
54.     void deleteSocket(SOCKET s)  
55.     {  
56.         for (int i=0;i<FD_SETSIZE;i++)  
57.         {  
58.             if (socketArray[i]==s)  
59.             {  
60.                 socketArray[i]=0;  
61.                 num--;  
62.                 break;  
63.             }  
64.         }  
65.     }  
66.   
67.     //将socketArray中的套接字放入fd_list这个结构体中  
68.     void makefd(fd_set * fd_list)  
69.     {  
70.             FD_ZERO(fd_list);//首先将fd_list清0  
71.   
72.             //将每一个socket加入fd_list中  
73.             for (int i=0;i<FD_SETSIZE;i++)  
74.             {  
75.                 if (socketArray[i]>0)  
76.                 {  
77.                     FD_SET(socketArray[i],fd_list);  
78.                 }  
79.             }  
80.     }  
81.   
82. };  
83.   
84.   
85. //使用这一个线程来通过select来处理多个socket  
86. DWORD WINAPI workThread(LPVOID lpParam)  
87. {  
88.         //传递进来的socketList指针  
89.         SocketList * socketList=(SocketList *)lpParam;  
90.         int err=0;  
91.         fd_set fdread;//存在读文件的set，select会检测这个set中是否可以从某些socket中读入信息  
92.   
93.         struct timeval timeout;//设置select超时的时间  
94.         timeout.tv_sec=6;  
95.         timeout.tv_usec=0;  
96.   
97.         //输入输出缓冲区  
98.         char receBuff[MAX_PATH];  
99.         char sendBuf[MAX_PATH];  
100.   
101.         SOCKET socket;  
102.   
103.         while(true)  
104.         {  
105.                 socketList->makefd(&fdread);  
106.                 err=select(0,&fdread,NULL,NULL,&timeout);  
107.                 if (err==0)//select返回0表示超时  
108.                 {  
109.                     cout<<"select() is time-out!"<<endl;  
110.                     continue;  
111.                 }  
112.                 else  
113.                 {  
114.                     //遍历socketList中的每一个socket，查看那些socket是可读的，处理可读的socket  
115.                     //从中读取数据到缓冲区，并发送数据给客户端  
116.                         for (int i=0;i<FD_SETSIZE;i++)  
117.                         {  
118.                             //读取有效的socket  
119.                             if (socketList->getSocket(i)==0)  
120.                                     continue;  
121.                             socket=socketList->getSocket(i);  
122.   
123.                             //判断哪些socket是可读的，如果这个socket是可读的，从它里面读取数据  
124.                             if (FD_ISSET(socket,&fdread))  
125.                             {  
126.                                 err=recv(socket,receBuff,MAX_PATH,0);  
127.   
128.                                 //如果返回值表示要关闭这个连接，那么关闭它，并将它从sockeList中去掉  
129.                                 if (err==0||err==SOCKET_ERROR)  
130.                                 {  
131.                                     closesocket(socket);  
132.                                     cout<<"断开连接!"<<endl;  
133.                                     socketList->deleteSocket(socket);  
134.                                 }  
135.                                 else  
136.                                 {  
137.                                     cout<<"message from client:"<<receBuff<<endl;  
138.   
139.                                     strcpy(sendBuf,"server receive a message:");  
140.                                     strcat(sendBuf,receBuff);  
141.                                     //发送数据  
142.                                     send(socket,sendBuf,strlen(sendBuf)+1,0);   //第三个参数加上1是为了将字符串结束符'\0'也发送过去     
143.                                 }  
144.   
145.                             }//end if  
146.   
147.                         }//end for  
148.   
149.                 }//end if (err==0)  
150.   
151.         }//end while  
152.   
153.   
154.         return 0;  
155. }  
156.   
157. void main()  
158. {  
159.       
160.     WSADATA wsaData;  
161.     int err;  
162.   
163.     //1.加载套接字库  
164.     err=WSAStartup(MAKEWORD(1,1),&wsaData);  
165.     if (err!=0)  
166.     {  
167.         cout<<"Init Windows Socket Failed::"<<GetLastError()<<endl;  
168.         return ;  
169.     }  
170.   
171.     //2.创建socket  
172.     //套接字描述符,SOCKET实际上是unsigned int  
173.     SOCKET serverSocket;  
174.     serverSocket=socket(AF_INET,SOCK_STREAM,0);  
175.     if (serverSocket==INVALID_SOCKET)  
176.     {  
177.         cout<<"Create Socket Failed::"<<GetLastError()<<endl;  
178.         return ;  
179.     }  
180.   
181.   
182.     //服务器端的地址和端口号  
183.     struct sockaddr_in serverAddr,clientAdd;  
184.     serverAddr.sin_addr.s_addr=inet_addr(IP_ADDRESS);  
185.     serverAddr.sin_family=AF_INET;  
186.     serverAddr.sin_port=htons(PORT);  
187.   
188.     //3.绑定Socket，将Socket与某个协议的某个地址绑定  
189.     err=bind(serverSocket,(struct sockaddr*)&serverAddr,sizeof(serverAddr));  
190.     if (err!=0)  
191.     {  
192.         cout<<"Bind Socket Failed::"<<GetLastError()<<endl;  
193.         return ;  
194.     }  
195.   
196.   
197.     //4.监听,将套接字由默认的主动套接字转换成被动套接字  
198.     err=listen(serverSocket,10);  
199.     if (err!=0)  
200.     {  
201.         cout<<"listen Socket Failed::"<<GetLastError()<<endl;  
202.         return ;  
203.     }  
204.   
205.     cout<<"服务器端已启动......"<<endl;  
206.   
207.     int addrLen=sizeof(clientAdd);  
208.     SOCKET sockConn;  
209.     SocketList socketList;  
210.     HANDLE hThread=CreateThread(NULL,0,workThread,&socketList,0,NULL);  
211.     if (hThread==NULL)  
212.     {  
213.         cout<<"Create Thread Failed!"<<endl;  
214.     }  
215.     CloseHandle(hThread);  
216.   
217.     while(true)  
218.     {  
219.         //5.接收请求，当收到请求后，会将客户端的信息存入clientAdd这个结构体中，并返回描述这个TCP连接的Socket  
220.         sockConn=accept(serverSocket,(struct sockaddr*)&clientAdd,&addrLen);  
221.         if (sockConn==INVALID_SOCKET)  
222.         {  
223.             cout<<"Accpet Failed::"<<GetLastError()<<endl;  
224.             return ;  
225.         }  
226.         cout<<"客户端连接："<<inet_ntoa(clientAdd.sin_addr)<<":"<<clientAdd.sin_port<<endl;  
227.           
228.         //将之前的第6步替换成了上面启动workThread这个线程函数和下面这一行代码  
229.         //将socket放入socketList中  
230.         socketList.insertSocket(sockConn);  
231.     }  
232.   
233.     closesocket(serverSocket);  
234.     //清理Windows Socket库  
235.     WSACleanup();  
236. }  

客户端的代码和前面是一样的，这里就不再列出来了。

程序执行的效果：

上面服务器端显示selecet() is time-out!是指超过了你设置的传递给select的timeout时间后仍然没有socket发送数据过来，此时select会返回，但是可以从这个返回的状态码中判断是否有socket可读。