基于事件的select：WSAEventSelect模型

总结：

使用事件的机制，实现了监听socket的accept和客户端的read之间，以及各个客户端之间的read，可以不用一直阻塞在那，而是在有相应事件的时候再进行阻塞处理，消除了accept和read的长阻塞，增加了一个WSAWaitForMultipleEvents长阻塞。

  该模型与WSAAsyncSelect模型类似，允许应用程序在一个或多个套接字上接受基于事件的网络通知。它与WSAAsyncSelect模型类似是因为它也接收FD_XXX类型的网络事件，不过并不是依靠Windows的消息驱动机制，而是经由事件对象句柄通知。

    使用这个模型的基本思路是为感兴趣的一组网络事件创建一个事件对象，再调用WSAEventSelect函数将网络事件和事件对象、套接字关联起来。当网络事件发生时，Winsock使相应的事件对象受信，在事件对象上的等待函数就会返回。之后，调用WSAEnumNetworkEvents函数便可获取到底发生了什么网络事件。

    WSAEVENT WSACreateEvent(void);           // 返回一个手工重置的事件对象句柄（如果自动重置，可用CreateEvent）

    int WSAEventSelect(

          SOCKET s,                                               // 套接字句柄

          WSAEVENT hEventObject,                    // 上述描述的创建的事件对象句柄

          long lNetworkEvents                              // 感兴趣的FD_XXX网络事件的组合

    );

    DWORD WSAWaitForMultipleEvents(

          DOWRD cEvents,                                   // 指定下面lphEvents所指的数组中事件对象句柄的个数

          const WSAEVENT* lphEvents,             // 指向一个事件对象句柄数组

          BOOL fWaitAll,                                         // 指定是否等待所有事件对象都变成受信状态

          DWORD dwTimeout,                             // 指定要等待的时间，WSA_INFINITE为无穷大（0，函数立即返回，马上知道事件对象此刻是否受信）

          BOOL fAlertable                                      // 在使用WSAEventSelect模型时可以忽略，应设为FALSE

    );

DWORD WSAAPI WSAWaitForMultipleEvents( DWORD

cEvents,

const WSAEVENT FAR * lphEvents, BOOL fWaitAll,

DWORD dwTimeout,

BOOL fAlertable );

cEvents：指出lphEvents所指数组中事件对象句柄的数目。事件对象句柄的最大值为WSA_MAXIMUM_WAIT_EVENTS。

lphEvents：指向一个事件对象句柄数组的指针。

fWaitAll：指定等待类型。若为真TRUE，则当lphEvents数组中的所有事件对象同时有信号时，函数返回。若为假FALSE，则当任意一个事件对象有信号时函数即返回。在后一种情况下，返回值指出是哪一个事件对象造成函数返回。

dwTimeout：指定超时时间间隔（以毫秒计）。当超时间隔到，函数即返回，不论fWaitAll参数所指定的条件是否满足。如果dwTimeout为零，则函数测试指定的时间对象的状态，并立即返回。如果dwTimeout是WSA_INFINITE，则函数的超时间隔永远不会到。

fAlertable：指定当系统将一个输入/输出完成例程放入队列以供执行时，函数是否返回。若为真TRUE，则函数返回且执行完成例程。若为假FALSE，函数不返回，不执行完成例程。请注意在Win16中忽略该参数。

返回值：

如果函数成功，返回值指出造成函数返回的事件对象。(这一句有问题)，应该改成：如果事件数组中有某一个事件被传信了，函数会返回这个事件的索引值，但是这个索引值需要减去预定义值 WSA_WAIT_EVENT_0才是这个事件在事件数组中的位置。

如果函数失败，返回值为WSA_WAIT_FAILED。可调用WSAGetLastError()来获取进一步的错误信息。

错误代码：

WSANOTINITIALISED 在调用本API之前应成功调用WSAStartup()。

WSAENETDOWN 网络子系统失效。

WSA_NOT_ENOUGH_MEMORY 无足够内存完成该操作。

WSA_INVALID_HANDLE lphEvents数组中的一个或多个值不是合法的事件对象句柄。

WSA_INVALID_PARAMETER cEvents参数未包含合法的句柄数目。

    WSAWaitForMultipleEvents最多支持WSA_MAXIMUM_WAIT_EVENTS个对象，WSA_MAXIMUM_WAIT_EVENTS被定义为64。因此，这个I/O模型在一个线程中同一时间最多能支持64个套接字，如果需要使用这个模型管理更多套接字，就需要创建额外的工作线程了。

    WSAWaitForMultipleEvents的返回值：1. WSA_WAIT_TIMEOUT（超时）；2. 如果指定时间内有网络事件发生，返回值指明哪个事件对象促使函数返回，WSA_WAIT_EVENT_0 to (WSA_WAIT_EVENT_0 + cEvents - 1) ；3. WSA_WAIT_FAILED；4. WAIT_IO_COMPLETION，此模型不用。

    注意，将fWaitAll参数设为FALSE以后，如果同时有几个事件对象受信，WSAWaitForMultipleEvents函数的返回值也仅能指明一个，就是句柄数组中最前面的那个。如果指明的这个事件对象总有网络事件发生，那么后面其他事件对象所关联的网络事件就得不到处理了。解决办法是，WSAWaitForMultipleEvents函数返回后，对每个事件都再次调用WSAWaitForMultipleEvents函数，以便确定其状态。

    一旦事件对象受信，那么找到与之对应的套接字，然后调用WSAEnumNetworkEvents函数即可查看发生了什么网络事件。

    int WSAEnumNetworkEvents(

          SOCKET s,                                                     // 套接字句柄

          WSAEVENT hEventObject,                          // 对应的事件对象句柄。如果提供了此参数，本函数会重置这个事件对象的状态

          LPWSANETWORKEVENTS lpNetworkEvents               // 指向一个WSANETWORKEVENTS结构

    );

    最后一个参数用来取得在套接字上发生的网络事件和相关的出错代码，

    typedef struct WSANETWORKEVENTS{

               long lNetworkEvents;                                              // 指定已发生的网络事件（如FD_ACCEPT、FD_READ等）

               int iErrorCode[FD_MAX_EVENTS];                       // 与lNetworkEvents相关的出错代码

    } WSANETWORKEVENTS, *LPWSANETWORKEVENTS;

    iErrorCode的每个成员对应着一个网络事件的出错代码，可以用预定义标识FD_READ_BIT、FD_WRITE_BIT等来索引FD_READ、FD_WRITE等事件发生时的出错代码。如：

    if(event.lNetworkEvent & FD_READ)           // 处理FD_READ通知消息

    {

        if(event.iErrorCode[FD_READ_BIT] != 0)

        {

            ......                             // FD_READ出错，错误代码为event.iErrorCode[FD_READ_BIT]

        }

    }

    给出实例，仍旧为TCP服务器程序，打印出接受数据。步骤如下：

    （1）创建一个事件句柄表和一个对应的套接字句柄表。

    （2）每创建一个套接字，就创建一个事件对象，把它们的句柄分别放入上面的两个表中，并调用WSAEventSelect添加它们的关联。

    （3）调用WSAWaitForMultipleEvents在所有事件对象上等待，此函数返回后，我们对事件句柄表中的每个事件调用WSAWaitForMultipleEvents函数，以便确认在哪些套接字上发生了网络事件。

    （4）WSAEnumNetworkEvents处理发生的网络事件，继续在事件对象上等待。

[cpp] view plaincopy

1. // initsock.h  
2.   
3. #include <winsock2.h>  
4. #pragma comment(lib, "WS2_32")  
5.   
6. class CInitSock  
7. {  
8. public:  
9.     CInitSock();  
10.     ~CInitSock();  
11. };  
12.   
13. inline CInitSock::CInitSock()  
14. {  
15.     // 初始化WS2_32.dll  
16.     WSADATA wsaData;  
17.     WORD sockVersion = MAKEWORD(2, 2);  
18.     if(::WSAStartup(sockVersion, &wsaData) != 0)  
19.     {  
20.         exit(0);  
21.     }  
22. }  
23.   
24. inline CInitSock::~CInitSock()  
25. {  
26.     ::WSACleanup();   
27. }  
28.   
29. //////////////////////////////////////////////////  
30. // WSAEventSelect文件  
31.   
32. #include "initsock.h"  
33. #include <stdio.h>  
34. #include <iostream>  
35. #include <windows.h>  
36. using namespace std;  
37.   
38. // 初始化Winsock库  
39. CInitSock theSock;  
40.   
41. int main()  
42. {  
43.     // 事件句柄和套节字句柄表  
44.     WSAEVENT    eventArray[WSA_MAXIMUM_WAIT_EVENTS];  
45.     SOCKET      sockArray[WSA_MAXIMUM_WAIT_EVENTS];  
46.     int nEventTotal = 0;  
47.   
48.     USHORT nPort = 4567;    // 此服务器监听的端口号  
49.   
50.     // 创建监听套节字  
51.     SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);     
52.     sockaddr_in sin;  
53.     sin.sin_family = AF_INET;  
54.     sin.sin_port = htons(nPort);  
55.     sin.sin_addr.S_un.S_addr = INADDR_ANY;  
56.     if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)  
57.     {  
58.         printf(" Failed bind() \n");  
59.         return -1;  
60.     }  
61.     ::listen(sListen, 5);  
62.   
63.     // 创建事件对象，并关联到新的套节字  
64.     WSAEVENT event = ::WSACreateEvent();  
65.     ::WSAEventSelect(sListen, event, FD_ACCEPT|FD_CLOSE);  
66.     // 添加到表中  
67.     eventArray[nEventTotal] = event;  
68.     sockArray[nEventTotal] = sListen;     
69.     nEventTotal++;  
70.   
71.     // 处理网络事件  
72.     while(TRUE)  
73.     {  
74.         // 在所有事件对象上等待  
75.         int nIndex = ::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA_INFINITE, FALSE);  
76.         // 对每个事件调用WSAWaitForMultipleEvents函数，以便确定它的状态  
77.         nIndex = nIndex - WSA_WAIT_EVENT_0;  
78.         for(int i=nIndex; i<nEventTotal; i++)  
79.         {  
80.             nIndex = ::WSAWaitForMultipleEvents(1, &eventArray[i], TRUE, 1000, FALSE);  
81.             if(nIndex == WSA_WAIT_FAILED || nIndex == WSA_WAIT_TIMEOUT)  
82.             {  
83.                 continue;  
84.             }  
85.             else  
86.             {  
87.                 // 获取到来的通知消息，WSAEnumNetworkEvents函数会自动重置受信事件  
88.                 WSANETWORKEVENTS event;  
89.                 ::WSAEnumNetworkEvents(sockArray[i], eventArray[i], &event);  
90.                 if(event.lNetworkEvents & FD_ACCEPT)                // 处理FD_ACCEPT通知消息  
91.                 {  
92.                     if(event.iErrorCode[FD_ACCEPT_BIT] == 0)  
93.                     {  
94.                         if(nEventTotal > WSA_MAXIMUM_WAIT_EVENTS)  
95.                         {  
96.                             printf(" Too many connections! \n");  
97.                             continue;  
98.                         }  
99.                         SOCKET sNew = ::accept(sockArray[i], NULL, NULL);  
100.                         WSAEVENT event = ::WSACreateEvent();  
101.                         ::WSAEventSelect(sNew, event, FD_READ|FD_CLOSE|FD_WRITE);  
102.                         // 添加到表中  
103.                         eventArray[nEventTotal] = event;  
104.                         sockArray[nEventTotal] = sNew;    
105.                         nEventTotal++;  
106.                     }  
107.                 }  
108.                 else if(event.lNetworkEvents & FD_READ)         // 处理FD_READ通知消息  
109.                 {  
110.                     if(event.iErrorCode[FD_READ_BIT] == 0)  
111.                     {  
112.                         char szText[256];  
113.                         int nRecv = ::recv(sockArray[i], szText, strlen(szText), 0);  
114.                         if(nRecv > 0)                  
115.                         {  
116.                             szText[nRecv] = '\0';  
117.                             printf("接收到数据：%s \n", szText);  
118.                         }  
119.                     }  
120.                 }  
121.                 else if(event.lNetworkEvents & FD_CLOSE)        // 处理FD_CLOSE通知消息  
122.                 {  
123.                     if(event.iErrorCode[FD_CLOSE_BIT] == 0)  
124.                     {  
125.                         ::closesocket(sockArray[i]);  
126.                         ::CloseHandle(eventArray[i]);  
127.                         for(int j=i; j<nEventTotal-1; j++)  
128.                         {  
129.                             sockArray[j] = sockArray[j+1];  
130. /*                          sockArray[j] = sockArray[j+1];  */  
131.                             eventArray[j] = eventArray[j+1];  
132.                         }  
133.                         nEventTotal--;  
134.                     }  
135.                 }  
136.                 else if(event.lNetworkEvents & FD_WRITE)        // 处理FD_WRITE通知消息  
137.                 {  
138.                 }  
139.             }  
140.         }  
141.     }  
142.     return 0;  
143. }  

    WSAEventSelect模型简单易用，也不需要窗口坏境。该模型唯一缺点是有最多等待64个事件对象的限制，当套接字连接数量增加时，就必须创建多个线程来处理I/O，也就是使用所谓的线程池。

    接下来采用该模型设计一个可以处理大量客户I/O请求的服务器程序。

    设计的总体思路比较简单，程序的主线程负责监听客户端的连接请求，接受到新连接之后，将新套接字安排给工作线程处理I/O。每个工作线程最多处理64个套接字，如果再有新的套接字，就再创建新的工作线程。

    程序用下面的SOCKET_OBJ结构来记录每个客户端套接字的信息。

[cpp] view plaincopy

1. // 套节字对象  
2. typedef struct _SOCKET_OBJ  
3. {  
4.     SOCKET s;                   // 套节字句柄  
5.     HANDLE event;               // 与此套节字相关联的事件对象句柄  
6.     sockaddr_in addrRemote;     // 客户端地址信息  
7.   
8.     _SOCKET_OBJ *pNext;         // 指向下一个SOCKET_OBJ对象，为的是连成一个表  
9. } SOCKET_OBJ, *PSOCKET_OBJ;  

    每接受到一个新的连接，便为新连接申请一个SOCKET_OBJ结构，初始化该结构的成员。当连接关闭或者出错时，再释放内存空间。下面的GetSocketObj和FreeSocketObj函数分别用于申请和释放一个SOCKET_OBJ对象。

[cpp] view plaincopy

1. // 申请一个套节字对象，初始化它的成员  
2. PSOCKET_OBJ GetSocketObj(SOCKET s)    
3. {  
4.     PSOCKET_OBJ pSocket = (PSOCKET_OBJ)::GlobalAlloc(GPTR, sizeof(SOCKET_OBJ));  
5.     if(pSocket != NULL)  
6.     {  
7.         pSocket->s = s;  
8.         pSocket->event = ::WSACreateEvent();  
9.     }  
10.     return pSocket;  
11. }  
12.   
13. // 释放一个套节字对象  
14. void FreeSocketObj(PSOCKET_OBJ pSocket)  
15. {  
16.     ::CloseHandle(pSocket->event);  
17.     if(pSocket->s != INVALID_SOCKET)  
18.     {  
19.         ::closesocket(pSocket->s);  
20.     }  
21.     ::GlobalFree(pSocket);  
22. }  

   下面的THREAD_OBJ结构来记录每个线程的信息。

[cpp] view plaincopy

1. // 线程对象  
2. typedef struct _THREAD_OBJ  
3. {  
4.     HANDLE events[WSA_MAXIMUM_WAIT_EVENTS]; // 记录当前线程要等待的事件对象的句柄  
5.     int nSocketCount;                       // 记录当前线程处理的套节字的数量 <=  WSA_MAXIMUM_WAIT_EVENTS  
6.   
7.     PSOCKET_OBJ pSockHeader;                // 当前线程处理的套节字对象列表，pSockHeader指向表头  
8.     PSOCKET_OBJ pSockTail;                  // pSockTail指向表尾  
9.   
10.     CRITICAL_SECTION cs;                    // 关键代码段变量，为的是同步对本结构的访问  
11.     _THREAD_OBJ *pNext;                     // 指向下一个THREAD_OBJ对象，为的是连成一个表  
12.   
13. } THREAD_OBJ, *PTHREAD_OBJ;  

    套接字对象列表记录在它所属的线程对象内，线程对象列表记录在全局变量中，下面定义全局变量g_pThreadList做这件事。

[cpp] view plaincopy

1. // 线程列表  
2. PTHREAD_OBJ g_pThreadList;      // 指向线程对象列表表头  
3. CRITICAL_SECTION g_cs;          // 同步对此全局变量的访问  

    当客户数量增加时，服务器就要创建额外的线程去处理I/O。每创建一个线程，便为新线程申请一个THREAD_OBJ结构，初始化该结构的成员。当客户数量减小，处理I/O的线程关闭时，再释放内存空间。下面的GetThreadObj和FreeThreadObj函数分别用于申请和释放一个THREAD_OBJ对象。

[cpp] view plaincopy

1. // 申请一个线程对象，初始化它的成员，并将它添加到线程对象列表中  
2. PTHREAD_OBJ GetThreadObj()  
3. {  
4.     PTHREAD_OBJ pThread = (PTHREAD_OBJ)::GlobalAlloc(GPTR, sizeof(THREAD_OBJ));  
5.     if(pThread != NULL)  
6.     {     
7.         ::InitializeCriticalSection(&pThread->cs);  
8.         // 创建一个事件对象，用于指示该线程的句柄数组需要重组  
9.         pThread->events[0] = ::WSACreateEvent();  
10.   
11.         // 将新申请的线程对象添加到列表中  
12.         ::EnterCriticalSection(&g_cs);  
13.         pThread->pNext = g_pThreadList;  
14.         g_pThreadList = pThread;  
15.         ::LeaveCriticalSection(&g_cs);  
16.     }  
17.     return pThread;  
18. }  
19.   
20. // 释放一个线程对象，并将它从线程对象列表中移除  
21. void FreeThreadObj(PTHREAD_OBJ pThread)  
22. {  
23.     // 在线程对象列表中查找pThread所指的对象，如果找到就从中移除  
24.     ::EnterCriticalSection(&g_cs);  
25.     PTHREAD_OBJ p = g_pThreadList;  
26.     if(p == pThread)        // 是第一个？  
27.     {  
28.         g_pThreadList = p->pNext;  
29.     }  
30.     else  
31.     {  
32.         while(p != NULL && p->pNext != pThread)  
33.         {  
34.             p = p->pNext;  
35.         }  
36.         if(p != NULL)  
37.         {  
38.             // 此时，p是pThread的前一个，即“p->pNext == pThread”  
39.             p->pNext = pThread->pNext;  
40.         }  
41.     }  
42.     ::LeaveCriticalSection(&g_cs);  
43.   
44.     // 释放资源  
45.     ::CloseHandle(pThread->events[0]);  
46.     ::DeleteCriticalSection(&pThread->cs);  
47.     ::GlobalFree(pThread);  
48. }  

    线程启动之后，要在events数组记录的事件上等待。下面的RebuildArray函数将与套接字相关联的事件对象的句柄写入这个数组。

[cpp] view plaincopy

1. // 重新建立线程对象的events数组  
2. void RebuildArray(PTHREAD_OBJ pThread)    
3. {  
4.     ::EnterCriticalSection(&pThread->cs);  
5.     PSOCKET_OBJ pSocket = pThread->pSockHeader;  
6.     int n = 1;  // 从第1个开始写，第0个用于指示需要重建了  
7.     while(pSocket != NULL)  
8.     {  
9.         pThread->events[n++] = pSocket->event;  
10.         pSocket = pSocket->pNext;  
11.     }  
12.     ::LeaveCriticalSection(&pThread->cs);  
13. }  

    在线程运行期间，如果有新的套接字对象添加到这个线程，就使events[0]事件对象受信，通知线程重新调用RebuildArray函数建立events数组

 
    程序的主线程负责接受客户的连接请求，创建处理客户请求的线程，打印服务器的状态信息。该服务器程序仅维护下面两个状态，它们被定义为全局变量。

[cpp] view plaincopy

1. // 状态信息  
2. LONG g_nTatolConnections;       // 总共连接数量  
3. LONG g_nCurrentConnections;     // 当前连接数量  

    主线程在接受到客户请求之后，使用下面两个函数将新的连接安排给其他线程处理。

[cpp] view plaincopy

1. // 向一个线程的套节字列表中插入一个套节字  
2. BOOL InsertSocketObj(PTHREAD_OBJ pThread, PSOCKET_OBJ pSocket)  
3. {  
4.     BOOL bRet = FALSE;  
5.     ::EnterCriticalSection(&pThread->cs);  
6.     if(pThread->nSocketCount < WSA_MAXIMUM_WAIT_EVENTS - 1)  
7.     {  
8.         if(pThread->pSockHeader == NULL)  
9.         {  
10.             pThread->pSockHeader = pThread->pSockTail = pSocket;  
11.         }  
12.         else  
13.         {  
14.             pThread->pSockTail->pNext = pSocket;  
15.             pThread->pSockTail = pSocket;  
16.         }  
17.         pThread->nSocketCount ++;  
18.         bRet = TRUE;  
19.     }  
20.     ::LeaveCriticalSection(&pThread->cs);  
21.   
22.     // 插入成功，说明成功处理了客户的连接请求  
23.     if(bRet)  
24.     {  
25.         ::InterlockedIncrement(&g_nTatolConnections);  
26.         ::InterlockedIncrement(&g_nCurrentConnections);  
27.     }     
28.     return bRet;  
29. }  
30.   
31. // 将一个套节字对象安排给空闲的线程处理  
32. void AssignToFreeThread(PSOCKET_OBJ pSocket)  
33. {     
34.     pSocket->pNext = NULL;  
35.   
36.     ::EnterCriticalSection(&g_cs);  
37.     PTHREAD_OBJ pThread = g_pThreadList;  
38.     // 试图插入到现存线程  
39.     while(pThread != NULL)  
40.     {  
41.         if(InsertSocketObj(pThread, pSocket))  
42.             break;  
43.         pThread = pThread->pNext;  
44.     }  
45.   
46.     // 没有空闲线程，为这个套节字创建新的线程  
47.     if(pThread == NULL)  
48.     {  
49.         pThread = GetThreadObj();  
50.         InsertSocketObj(pThread, pSocket);    
51.         ::CreateThread(NULL, 0, ServerThread, pThread, 0, NULL);  
52.     }  
53.     ::LeaveCriticalSection(&g_cs);  
54.   
55.     // 指示线程重建句柄数组  
56.     ::WSASetEvent(pThread->events[0]);  
57. }  

    连接中断之后，要先将中断的套接字对应的套接字对象从线程对象中移除，再释放套接字对象。下面的RemoveSocketObj函数从给定线程的套接字对象列表中移除一个套接字对象。

[cpp] view plaincopy

1. // 从给定线程的套节字对象列表中移除一个套节字对象  
2. void RemoveSocketObj(PTHREAD_OBJ pThread, PSOCKET_OBJ pSocket)  
3. {  
4.     ::EnterCriticalSection(&pThread->cs);  
5.   
6.     // 在套节字对象列表中查找指定的套节字对象，找到后将之移除  
7.     PSOCKET_OBJ pTest = pThread->pSockHeader;  
8.     if(pTest == pSocket)  
9.     {  
10.         if(pThread->pSockHeader == pThread->pSockTail)  
11.             pThread->pSockTail = pThread->pSockHeader = pTest->pNext;  
12.         else  
13.             pThread->pSockHeader = pTest->pNext;  
14.     }  
15.     else  
16.     {  
17.         while(pTest != NULL && pTest->pNext != pSocket)  
18.             pTest = pTest->pNext;  
19.         if(pTest != NULL)  
20.         {  
21.             if(pThread->pSockTail == pSocket)  
22.                 pThread->pSockTail = pTest;  
23.             pTest->pNext = pSocket->pNext;  
24.         }  
25.     }  
26.     pThread->nSocketCount --;  
27.   
28.     ::LeaveCriticalSection(&pThread->cs);  
29.   
30.     // 指示线程重建句柄数组  
31.     ::WSASetEvent(pThread->events[0]);  
32.   
33.     // 说明一个连接中断  
34.     ::InterlockedDecrement(&g_nCurrentConnections);  
35. }  

    工作线程ServerThread负责处理客户的I/O请求。该线程运行之后，取得本线程对象的指针，进入无限循环并在events数组所记录的事件对象上等待，处理网络事件。具体如下：

[cpp] view plaincopy

1. DWORD WINAPI ServerThread(LPVOID lpParam)  
2. {  
3.     // 取得本线程对象的指针  
4.     PTHREAD_OBJ pThread = (PTHREAD_OBJ)lpParam;  
5.     while(TRUE)  
6.     {  
7.         //  等待网络事件  
8.         int nIndex = ::WSAWaitForMultipleEvents(  
9.                             pThread->nSocketCount + 1, pThread->events, FALSE, WSA_INFINITE, FALSE);  
10.         nIndex = nIndex - WSA_WAIT_EVENT_0;  
11.         // 查看受信的事件对象  
12.         for(int i=nIndex; i<pThread->nSocketCount + 1; i++)  
13.         {  
14.             nIndex = ::WSAWaitForMultipleEvents(1, &pThread->events[i], TRUE, 1000, FALSE);  
15.             if(nIndex == WSA_WAIT_FAILED || nIndex == WSA_WAIT_TIMEOUT)  
16.             {  
17.                 continue;  
18.             }  
19.             else  
20.             {  
21.                 if(i == 0)              // events[0]受信，重建数组  
22.                 {  
23.                     RebuildArray(pThread);  
24.                     // 如果没有客户I/O要处理了，则本线程退出  
25.                     if(pThread->nSocketCount == 0)  
26.                     {  
27.                         FreeThreadObj(pThread);  
28.                         return 0;  
29.                     }  
30.                     ::WSAResetEvent(pThread->events[0]);  
31.                 }  
32.                 else                    // 处理网络事件  
33.                 {  
34.                     // 查找对应的套节字对象指针，调用HandleIO处理网络事件  
35.                     PSOCKET_OBJ pSocket = (PSOCKET_OBJ)FindSocketObj(pThread, i);  
36.                     if(pSocket != NULL)  
37.                     {  
38.                         if(!HandleIO(pThread, pSocket))  
39.                             RebuildArray(pThread);  
40.                     }  
41.                     else  
42.                         printf(" Unable to find socket object \n ");  
43.                 }  
44.             }  
45.         }  
46.     }  
47.     return 0;  
48. }  

    FindSocketObj函数根据事件对象在events数组中的索引查找相应的套接字对象。

[cpp] view plaincopy

1. PSOCKET_OBJ FindSocketObj(PTHREAD_OBJ pThread, int nIndex) // nIndex从1开始  
2. {  
3.     // 在套节字列表中查找  
4.     PSOCKET_OBJ pSocket = pThread->pSockHeader;  
5.     while(--nIndex)  
6.     {  
7.         if(pSocket == NULL)  
8.             return NULL;  
9.         pSocket = pSocket->pNext;  
10.     }  
11.     retu  

    HandleIO函数调用WSAEnumNetworkEvents函数获取具体发生的网络事件，然后按照程序要实现的功能进行处理。

[cpp] view plaincopy

1. BOOL HandleIO(PTHREAD_OBJ pThread, PSOCKET_OBJ pSocket)  
2. {  
3.     // 获取具体发生的网络事件  
4.     WSANETWORKEVENTS event;  
5.     ::WSAEnumNetworkEvents(pSocket->s, pSocket->event, &event);  
6.     do  
7.     {  
8.         if(event.lNetworkEvents & FD_READ)          // 套节字可读  
9.         {  
10.             if(event.iErrorCode[FD_READ_BIT] == 0)  
11.             {  
12.                 char szText[256];  
13.                 int nRecv = ::recv(pSocket->s, szText, strlen(szText), 0);  
14.                 if(nRecv > 0)                  
15.                 {  
16.                     szText[nRecv] = '\0';  
17.                     printf("接收到数据：%s \n", szText);  
18.                 }  
19.             }  
20.             else  
21.                 break;  
22.         }  
23.         else if(event.lNetworkEvents & FD_CLOSE)    // 套节字关闭  
24.         {  
25.             break;  
26.         }  
27.         else if(event.lNetworkEvents & FD_WRITE)    // 套节字可写  
28.         {  
29.             if(event.iErrorCode[FD_WRITE_BIT] == 0)  
30.             {     
31.             }  
32.             else  
33.                 break;  
34.         }  
35.         return TRUE;  
36.     }  
37.     while(FALSE);  
38.   
39.     // 套节字关闭，或者有错误发生，程序都会转到这里来执行  
40.     RemoveSocketObj(pThread, pSocket);  
41.     FreeSocketObj(pSocket);  
42.     return FALSE;  
43. }  

    主线程创建监听套接字，初始化全局变量，处理客户端的连接请求，定时打印状态信息等。具体如下：

[cpp] view plaincopy

1. int main()  
2. {  
3.     USHORT nPort = 4567;    // 此服务器监听的端口号  
4.   
5.     // 创建监听套节字  
6.     SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);     
7.     sockaddr_in sin;  
8.     sin.sin_family = AF_INET;  
9.     sin.sin_port = htons(nPort);  
10.     sin.sin_addr.S_un.S_addr = INADDR_ANY;  
11.     if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)  
12.     {  
13.         printf(" Failed bind() \n");  
14.         return -1;  
15.     }  
16.     ::listen(sListen, 200);  
17.   
18.     // 创建事件对象，并关联到监听的套节字  
19.     WSAEVENT event = ::WSACreateEvent();  
20.     ::WSAEventSelect(sListen, event, FD_ACCEPT|FD_CLOSE);  
21.   
22.     ::InitializeCriticalSection(&g_cs);  
23.   
24.     // 处理客户连接请求，打印状态信息  
25.     while(TRUE)  
26.     {  
27.         int nRet = ::WaitForSingleObject(event, 5*1000);  
28.         if(nRet == WAIT_FAILED)  
29.         {  
30.             printf(" Failed WaitForSingleObject() \n");  
31.             break;  
32.         }  
33.         else if(nRet == WSA_WAIT_TIMEOUT)   // 定时显式状态信息  
34.         {  
35.             printf(" \n");  
36.             printf("   TatolConnections: %d \n", g_nTatolConnections);  
37.             printf(" CurrentConnections: %d \n", g_nCurrentConnections);  
38.             continue;  
39.         }  
40.         else                                // 有新的连接未决  
41.         {  
42.             ::ResetEvent(event);  
43.             // 循环处理所有未决的连接请求  
44.             while(TRUE)  
45.             {  
46.                 sockaddr_in si;  
47.                 int nLen = sizeof(si);  
48.                 SOCKET sNew = ::accept(sListen, (sockaddr*)&si, &nLen);  
49.                 if(sNew == SOCKET_ERROR)  
50.                     break;  
51.                 PSOCKET_OBJ pSocket = GetSocketObj(sNew);  
52.                 pSocket->addrRemote = si;  
53.                 ::WSAEventSelect(pSocket->s, pSocket->event, FD_READ|FD_CLOSE|FD_WRITE);  
54.                 AssignToFreeThread(pSocket);  
55.             }  
56.         }  
57.     }  
58.     ::DeleteCriticalSection(&g_cs);  
59.     return 0;  
60. }  

    下面附上完整代码：

[cpp] view plaincopy

1. //////////////////////////////////////////////////////////  
2. // initsock.h文件  
3.   
4. #include <winsock2.h>  
5. #pragma comment(lib, "WS2_32")  // 链接到WS2_32.lib  
6.   
7. class CInitSock       
8. {  
9. public:  
10.     CInitSock(BYTE minorVer = 2, BYTE majorVer = 2)  
11.     {  
12.         // 初始化WS2_32.dll  
13.         WSADATA wsaData;  
14.         WORD sockVersion = MAKEWORD(minorVer, majorVer);  
15.         if(::WSAStartup(sockVersion, &wsaData) != 0)  
16.         {  
17.             exit(0);  
18.         }  
19.     }  
20.     ~CInitSock()  
21.     {     
22.         ::WSACleanup();   
23.     }  
24. };  
25.   
26.   
27. /////////////////////////////////////////////////////  
28. // EventSelectServer.h文件  
29.   
30. DWORD WINAPI ServerThread(LPVOID lpParam);  
31.   
32.   
33. // 套节字对象  
34. typedef struct _SOCKET_OBJ  
35. {  
36.     SOCKET s;                   // 套节字句柄  
37.     HANDLE event;               // 与此套节字相关联的事件对象句柄  
38.     sockaddr_in addrRemote;     // 客户端地址信息  
39.   
40.     _SOCKET_OBJ *pNext;         // 指向下一个SOCKET_OBJ对象，为的是连成一个表  
41. } SOCKET_OBJ, *PSOCKET_OBJ;  
42.   
43. // 线程对象  
44. typedef struct _THREAD_OBJ  
45. {  
46.     HANDLE events[WSA_MAXIMUM_WAIT_EVENTS]; // 记录当前线程要等待的事件对象的句柄  
47.     int nSocketCount;                       // 记录当前线程处理的套节字的数量 <=  WSA_MAXIMUM_WAIT_EVENTS  
48.   
49.     PSOCKET_OBJ pSockHeader;                // 当前线程处理的套节字对象列表，pSockHeader指向表头  
50.     PSOCKET_OBJ pSockTail;                  // pSockTail指向表尾  
51.   
52.     CRITICAL_SECTION cs;                    // 关键代码段变量，为的是同步对本结构的访问  
53.     _THREAD_OBJ *pNext;                     // 指向下一个THREAD_OBJ对象，为的是连成一个表  
54.   
55. } THREAD_OBJ, *PTHREAD_OBJ;  
56.   
57. // 线程列表  
58. PTHREAD_OBJ g_pThreadList;      // 指向线程对象列表表头  
59. CRITICAL_SECTION g_cs;          // 同步对此全局变量的访问  
60.   
61.   
62. // 状态信息  
63. LONG g_nTatolConnections;       // 总共连接数量  
64. LONG g_nCurrentConnections;     // 当前连接数量  
65.   
66.   
67. // 申请一个套节字对象，初始化它的成员  
68. PSOCKET_OBJ GetSocketObj(SOCKET s)    
69. {  
70.     PSOCKET_OBJ pSocket = (PSOCKET_OBJ)::GlobalAlloc(GPTR, sizeof(SOCKET_OBJ));  
71.     if(pSocket != NULL)  
72.     {  
73.         pSocket->s = s;  
74.         pSocket->event = ::WSACreateEvent();  
75.     }  
76.     return pSocket;  
77. }  
78.   
79. // 释放一个套节字对象  
80. void FreeSocketObj(PSOCKET_OBJ pSocket)  
81. {  
82.     ::CloseHandle(pSocket->event);  
83.     if(pSocket->s != INVALID_SOCKET)  
84.     {  
85.         ::closesocket(pSocket->s);  
86.     }  
87.     ::GlobalFree(pSocket);  
88. }  
89.   
90. // 申请一个线程对象，初始化它的成员，并将它添加到线程对象列表中  
91. PTHREAD_OBJ GetThreadObj()  
92. {  
93.     PTHREAD_OBJ pThread = (PTHREAD_OBJ)::GlobalAlloc(GPTR, sizeof(THREAD_OBJ));  
94.     if(pThread != NULL)  
95.     {     
96.         ::InitializeCriticalSection(&pThread->cs);  
97.         // 创建一个事件对象，用于指示该线程的句柄数组需要重组  
98.         pThread->events[0] = ::WSACreateEvent();  
99.   
100.         // 将新申请的线程对象添加到列表中  
101.         ::EnterCriticalSection(&g_cs);  
102.         pThread->pNext = g_pThreadList;  
103.         g_pThreadList = pThread;  
104.         ::LeaveCriticalSection(&g_cs);  
105.     }  
106.     return pThread;  
107. }  
108.   
109. // 释放一个线程对象，并将它从线程对象列表中移除  
110. void FreeThreadObj(PTHREAD_OBJ pThread)  
111. {  
112.     // 在线程对象列表中查找pThread所指的对象，如果找到就从中移除  
113.     ::EnterCriticalSection(&g_cs);  
114.     PTHREAD_OBJ p = g_pThreadList;  
115.     if(p == pThread)        // 是第一个？  
116.     {  
117.         g_pThreadList = p->pNext;  
118.     }  
119.     else  
120.     {  
121.         while(p != NULL && p->pNext != pThread)  
122.         {  
123.             p = p->pNext;  
124.         }  
125.         if(p != NULL)  
126.         {  
127.             // 此时，p是pThread的前一个，即“p->pNext == pThread”  
128.             p->pNext = pThread->pNext;  
129.         }  
130.     }  
131.     ::LeaveCriticalSection(&g_cs);  
132.   
133.     // 释放资源  
134.     ::CloseHandle(pThread->events[0]);  
135.     ::DeleteCriticalSection(&pThread->cs);  
136.     ::GlobalFree(pThread);  
137. }  
138.   
139. // 重新建立线程对象的events数组  
140. void RebuildArray(PTHREAD_OBJ pThread)    
141. {  
142.     ::EnterCriticalSection(&pThread->cs);  
143.     PSOCKET_OBJ pSocket = pThread->pSockHeader;  
144.     int n = 1;  // 从第1个开始写，第0个用于指示需要重建了  
145.     while(pSocket != NULL)  
146.     {  
147.         pThread->events[n++] = pSocket->event;  
148.         pSocket = pSocket->pNext;  
149.     }  
150.     ::LeaveCriticalSection(&pThread->cs);  
151. }  
152.   
153. /////////////////////////////////////////////////////////////////////  
154.   
155. // 向一个线程的套节字列表中插入一个套节字  
156. BOOL InsertSocketObj(PTHREAD_OBJ pThread, PSOCKET_OBJ pSocket)  
157. {  
158.     BOOL bRet = FALSE;  
159.     ::EnterCriticalSection(&pThread->cs);  
160.     if(pThread->nSocketCount < WSA_MAXIMUM_WAIT_EVENTS - 1)  
161.     {  
162.         if(pThread->pSockHeader == NULL)  
163.         {  
164.             pThread->pSockHeader = pThread->pSockTail = pSocket;  
165.         }  
166.         else  
167.         {  
168.             pThread->pSockTail->pNext = pSocket;  
169.             pThread->pSockTail = pSocket;  
170.         }  
171.         pThread->nSocketCount ++;  
172.         bRet = TRUE;  
173.     }  
174.     ::LeaveCriticalSection(&pThread->cs);  
175.   
176.     // 插入成功，说明成功处理了客户的连接请求  
177.     if(bRet)  
178.     {  
179.         ::InterlockedIncrement(&g_nTatolConnections);  
180.         ::InterlockedIncrement(&g_nCurrentConnections);  
181.     }     
182.     return bRet;  
183. }  
184.   
185. // 将一个套节字对象安排给空闲的线程处理  
186. void AssignToFreeThread(PSOCKET_OBJ pSocket)  
187. {     
188.     pSocket->pNext = NULL;  
189.   
190.     ::EnterCriticalSection(&g_cs);  
191.     PTHREAD_OBJ pThread = g_pThreadList;  
192.     // 试图插入到现存线程  
193.     while(pThread != NULL)  
194.     {  
195.         if(InsertSocketObj(pThread, pSocket))  
196.             break;  
197.         pThread = pThread->pNext;  
198.     }  
199.   
200.     // 没有空闲线程，为这个套节字创建新的线程  
201.     if(pThread == NULL)  
202.     {  
203.         pThread = GetThreadObj();  
204.         InsertSocketObj(pThread, pSocket);    
205.         ::CreateThread(NULL, 0, ServerThread, pThread, 0, NULL);  
206.     }  
207.     ::LeaveCriticalSection(&g_cs);  
208.   
209.     // 指示线程重建句柄数组  
210.     ::WSASetEvent(pThread->events[0]);  
211. }  
212.   
213. // 从给定线程的套节字对象列表中移除一个套节字对象  
214. void RemoveSocketObj(PTHREAD_OBJ pThread, PSOCKET_OBJ pSocket)  
215. {  
216.     ::EnterCriticalSection(&pThread->cs);  
217.   
218.     // 在套节字对象列表中查找指定的套节字对象，找到后将之移除  
219.     PSOCKET_OBJ pTest = pThread->pSockHeader;  
220.     if(pTest == pSocket)  
221.     {  
222.         if(pThread->pSockHeader == pThread->pSockTail)  
223.             pThread->pSockTail = pThread->pSockHeader = pTest->pNext;  
224.         else  
225.             pThread->pSockHeader = pTest->pNext;  
226.     }  
227.     else  
228.     {  
229.         while(pTest != NULL && pTest->pNext != pSocket)  
230.             pTest = pTest->pNext;  
231.         if(pTest != NULL)  
232.         {  
233.             if(pThread->pSockTail == pSocket)  
234.                 pThread->pSockTail = pTest;  
235.             pTest->pNext = pSocket->pNext;  
236.         }  
237.     }  
238.     pThread->nSocketCount --;  
239.   
240.     ::LeaveCriticalSection(&pThread->cs);  
241.   
242.     // 指示线程重建句柄数组  
243.     ::WSASetEvent(pThread->events[0]);  
244.   
245.     // 说明一个连接中断  
246.     ::InterlockedDecrement(&g_nCurrentConnections);  
247. }  
248.   
249.   
250. BOOL HandleIO(PTHREAD_OBJ pThread, PSOCKET_OBJ pSocket)  
251. {  
252.     // 获取具体发生的网络事件  
253.     WSANETWORKEVENTS event;  
254.     ::WSAEnumNetworkEvents(pSocket->s, pSocket->event, &event);  
255.     do  
256.     {  
257.         if(event.lNetworkEvents & FD_READ)          // 套节字可读  
258.         {  
259.             if(event.iErrorCode[FD_READ_BIT] == 0)  
260.             {  
261.                 char szText[256];  
262.                 int nRecv = ::recv(pSocket->s, szText, strlen(szText), 0);  
263.                 if(nRecv > 0)                  
264.                 {  
265.                     szText[nRecv] = '\0';  
266.                     printf("接收到数据：%s \n", szText);  
267.                 }  
268.             }  
269.             else  
270.                 break;  
271.         }  
272.         else if(event.lNetworkEvents & FD_CLOSE)    // 套节字关闭  
273.         {  
274.             break;  
275.         }  
276.         else if(event.lNetworkEvents & FD_WRITE)    // 套节字可写  
277.         {  
278.             if(event.iErrorCode[FD_WRITE_BIT] == 0)  
279.             {     
280.             }  
281.             else  
282.                 break;  
283.         }  
284.         return TRUE;  
285.     }  
286.     while(FALSE);  
287.   
288.     // 套节字关闭，或者有错误发生，程序都会转到这里来执行  
289.     RemoveSocketObj(pThread, pSocket);  
290.     FreeSocketObj(pSocket);  
291.     return FALSE;  
292. }  
293.   
294. PSOCKET_OBJ FindSocketObj(PTHREAD_OBJ pThread, int nIndex) // nIndex从1开始  
295. {  
296.     // 在套节字列表中查找  
297.     PSOCKET_OBJ pSocket = pThread->pSockHeader;  
298.     while(--nIndex)  
299.     {  
300.         if(pSocket == NULL)  
301.             return NULL;  
302.         pSocket = pSocket->pNext;  
303.     }  
304.     return pSocket;  
305. }  
306.   
307. DWORD WINAPI ServerThread(LPVOID lpParam)  
308. {  
309.     // 取得本线程对象的指针  
310.     PTHREAD_OBJ pThread = (PTHREAD_OBJ)lpParam;  
311.     while(TRUE)  
312.     {  
313.         //  等待网络事件  
314.         int nIndex = ::WSAWaitForMultipleEvents(  
315.                             pThread->nSocketCount + 1, pThread->events, FALSE, WSA_INFINITE, FALSE);  
316.         nIndex = nIndex - WSA_WAIT_EVENT_0;  
317.         // 查看受信的事件对象  
318.         for(int i=nIndex; i<pThread->nSocketCount + 1; i++)  
319.         {  
320.             nIndex = ::WSAWaitForMultipleEvents(1, &pThread->events[i], TRUE, 1000, FALSE);  
321.             if(nIndex == WSA_WAIT_FAILED || nIndex == WSA_WAIT_TIMEOUT)  
322.             {  
323.                 continue;  
324.             }  
325.             else  
326.             {  
327.                 if(i == 0)              // events[0]受信，重建数组  
328.                 {  
329.                     RebuildArray(pThread);  
330.                     // 如果没有客户I/O要处理了，则本线程退出  
331.                     if(pThread->nSocketCount == 0)  
332.                     {  
333.                         FreeThreadObj(pThread);  
334.                         return 0;  
335.                     }  
336.                     ::WSAResetEvent(pThread->events[0]);  
337.                 }  
338.                 else                    // 处理网络事件  
339.                 {  
340.                     // 查找对应的套节字对象指针，调用HandleIO处理网络事件  
341.                     PSOCKET_OBJ pSocket = (PSOCKET_OBJ)FindSocketObj(pThread, i);  
342.                     if(pSocket != NULL)  
343.                     {  
344.                         if(!HandleIO(pThread, pSocket))  
345.                             RebuildArray(pThread);  
346.                     }  
347.                     else  
348.                         printf(" Unable to find socket object \n ");  
349.                 }  
350.             }  
351.         }  
352.     }  
353.     return 0;  
354. }  
355.   
356. ///////////////////////////////////////////  
357. // EventSelectServer.cpp文件  
358.   
359. #include "../common/initsock.h"  
360.   
361. #include <stdio.h>  
362. #include <windows.h>  
363.   
364. #include "EventSelectServer.h"  
365.   
366. // 初始化Winsock库  
367. CInitSock theSock;  
368.   
369. int main()  
370. {  
371.     USHORT nPort = 4567;    // 此服务器监听的端口号  
372.   
373.     // 创建监听套节字  
374.     SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);     
375.     sockaddr_in sin;  
376.     sin.sin_family = AF_INET;  
377.     sin.sin_port = htons(nPort);  
378.     sin.sin_addr.S_un.S_addr = INADDR_ANY;  
379.     if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)  
380.     {  
381.         printf(" Failed bind() \n");  
382.         return -1;  
383.     }  
384.     ::listen(sListen, 200);  
385.   
386.     // 创建事件对象，并关联到监听的套节字  
387.     WSAEVENT event = ::WSACreateEvent();  
388.     ::WSAEventSelect(sListen, event, FD_ACCEPT|FD_CLOSE);  
389.   
390.     ::InitializeCriticalSection(&g_cs);  
391.   
392.     // 处理客户连接请求，打印状态信息  
393.     while(TRUE)  
394.     {  
395.         int nRet = ::WaitForSingleObject(event, 5*1000);  
396.         if(nRet == WAIT_FAILED)  
397.         {  
398.             printf(" Failed WaitForSingleObject() \n");  
399.             break;  
400.         }  
401.         else if(nRet == WSA_WAIT_TIMEOUT)   // 定时显式状态信息  
402.         {  
403.             printf(" \n");  
404.             printf("   TatolConnections: %d \n", g_nTatolConnections);  
405.             printf(" CurrentConnections: %d \n", g_nCurrentConnections);  
406.             continue;  
407.         }  
408.         else                                // 有新的连接未决  
409.         {  
410.             ::ResetEvent(event);  
411.             // 循环处理所有未决的连接请求  
412.             while(TRUE)  
413.             {  
414.                 sockaddr_in si;  
415.                 int nLen = sizeof(si);  
416.                 SOCKET sNew = ::accept(sListen, (sockaddr*)&si, &nLen);  
417.                 if(sNew == SOCKET_ERROR)  
418.                     break;  
419.                 PSOCKET_OBJ pSocket = GetSocketObj(sNew);  
420.                 pSocket->addrRemote = si;  
421.                 ::WSAEventSelect(pSocket->s, pSocket->event, FD_READ|FD_CLOSE|FD_WRITE);  
422.                 AssignToFreeThread(pSocket);  
423.             }  
424.         }  
425.     }  
426.     ::DeleteCriticalSection(&g_cs);  
427.     return 0;  
428. }