Windows Socket五种I/O模型——代码全攻略(二)

 

四.重叠I/O模型 Winsock2的发布使得Socket I/O有了和文件I/O统一的接口。我们可以通过使用Win32文件操纵函数ReadFile和WriteFile来进行Socket I/O。伴随而来的，用于普通文件I/O的重叠I/O模型和完成端口模型对Socket I/O也适用了。这些模型的优点是可以达到更佳的系统性能，但是实现较为复杂，里面涉及较多的C语言技巧。例如我们在完成端口模型中会经常用到所谓的“尾随数据”。 1.用事件通知方式实现的重叠I/O模型 #include <winsock2.h> #include <stdio.h> #define PORT    5150 #define MSGSIZE 1024 #pragma comment(lib, "ws2_32.lib") typedef struct { WSAOVERLAPPED overlap; WSABUF        Buffer; char          szMessage[MSGSIZE]; DWORD         NumberOfBytesRecvd; DWORD         Flags; }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA; int                     g_iTotalConn = 0; SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS]; WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS]; LPPER_IO_OPERATION_DATA g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS]; DWORD WINAPI WorkerThread(LPVOID); void Cleanup(int); int main() { WSADATA     wsaData; SOCKET      sListen, sClient; SOCKADDR_IN local, client; DWORD       dwThreadId; int         iaddrSize = sizeof(SOCKADDR_IN); // Initialize Windows Socket library WSAStartup(0x0202, &wsaData); // Create listening socket sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Bind local.sin_addr.S_un.S_addr = htonl(INADDR_ANY); local.sin_family = AF_INET; local.sin_port = htons(PORT); bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN)); // Listen listen(sListen, 3); // Create worker thread CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); while (TRUE) {     // Accept a connection     sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);     printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));     g_CliSocketArr[g_iTotalConn] = sClient;         // Allocate a PER_IO_OPERATION_DATA structure     g_pPerIODataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(       GetProcessHeap(),       HEAP_ZERO_MEMORY,       sizeof(PER_IO_OPERATION_DATA));     g_pPerIODataArr[g_iTotalConn]->Buffer.len = MSGSIZE;     g_pPerIODataArr[g_iTotalConn]->Buffer.buf = g_pPerIODataArr[g_iTotalConn]->szMessage;     g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();     // Launch an asynchronous operation     WSARecv(       g_CliSocketArr[g_iTotalConn],       &g_pPerIODataArr[g_iTotalConn]->Buffer,       1,       &g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd,       &g_pPerIODataArr[g_iTotalConn]->Flags,       &g_pPerIODataArr[g_iTotalConn]->overlap,       NULL);         g_iTotalConn++; } closesocket(sListen); WSACleanup(); return 0; } DWORD WINAPI WorkerThread(LPVOID lpParam) { int   ret, index; DWORD cbTransferred; while (TRUE) {     ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);     if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)     {       continue;     }     index = ret - WSA_WAIT_EVENT_0;     WSAResetEvent(g_CliEventArr[index]);     WSAGetOverlappedResult(       g_CliSocketArr[index],       &g_pPerIODataArr[index]->overlap,       &cbTransferred,       TRUE,       &g_pPerIODataArr[g_iTotalConn]->Flags);     if (cbTransferred == 0)     {       // The connection was closed by client       Cleanup(index);     }     else     {       // g_pPerIODataArr[index]->szMessage contains the received data       g_pPerIODataArr[index]->szMessage[cbTransferred] = '/0';       send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,/         cbTransferred, 0);       // Launch another asynchronous operation       WSARecv(         g_CliSocketArr[index],         &g_pPerIODataArr[index]->Buffer,         1,         &g_pPerIODataArr[index]->NumberOfBytesRecvd,         &g_pPerIODataArr[index]->Flags,         &g_pPerIODataArr[index]->overlap,         NULL);     } } return 0; } void Cleanup(int index) { closesocket(g_CliSocketArr[index]); WSACloseEvent(g_CliEventArr[index]); HeapFree(GetProcessHeap(), 0, g_pPerIODataArr[index]); if (index < g_iTotalConn - 1) {     g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];     g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];     g_pPerIODataArr[index] = g_pPerIODataArr[g_iTotalConn - 1]; } g_pPerIODataArr[--g_iTotalConn] = NULL; } 这个模型与上述其他模型不同的是它使用Winsock2提供的异步I/O函数WSARecv。在调用WSARecv时，指定一个WSAOVERLAPPED结构，这个调用不是阻塞的，也就是说，它会立刻返回。一旦有数据到达的时候，被指定的WSAOVERLAPPED结构中的hEvent被Signaled。由于下面这个语句 g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent； 使得与该套接字相关联的WSAEVENT对象也被Signaled，所以WSAWaitForMultipleEvents的调用操作成功返回。我们现在应该做的就是用与调用WSARecv相同的WSAOVERLAPPED结构为参数调用WSAGetOverlappedResult，从而得到本次I/O传送的字节数等相关信息。在取得接收的数据后，把数据原封不动的发送到客户端，然后重新激活一个WSARecv异步操作。 2.用完成例程方式实现的重叠I/O模型 #include <WINSOCK2.H> #include <stdio.h> #define PORT    5150 #define MSGSIZE 1024 #pragma comment(lib, "ws2_32.lib") typedef struct { WSAOVERLAPPED overlap; WSABUF        Buffer; char          szMessage[MSGSIZE]; DWORD         NumberOfBytesRecvd; DWORD         Flags; SOCKET        sClient; }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA; DWORD WINAPI WorkerThread(LPVOID); void CALLBACK CompletionROUTINE(DWORD, DWORD, LPWSAOVERLAPPED, DWORD); SOCKET g_sNewClientConnection; BOOL   g_bNewConnectionArrived = FALSE; int main() { WSADATA     wsaData; SOCKET      sListen; SOCKADDR_IN local, client; DWORD       dwThreadId; int         iaddrSize = sizeof(SOCKADDR_IN); // Initialize Windows Socket library WSAStartup(0x0202, &wsaData); // Create listening socket sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Bind local.sin_addr.S_un.S_addr = htonl(INADDR_ANY); local.sin_family = AF_INET; local.sin_port = htons(PORT); bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN)); // Listen listen(sListen, 3); // Create worker thread CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); while (TRUE) {     // Accept a connection     g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize);     g_bNewConnectionArrived = TRUE;     printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port)); } } DWORD WINAPI WorkerThread(LPVOID lpParam) { LPPER_IO_OPERATION_DATA lpPerIOData = NULL; while (TRUE) {     if (g_bNewConnectionArrived)     {       // Launch an asynchronous operation for new arrived connection       lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(         GetProcessHeap(),         HEAP_ZERO_MEMORY,         sizeof(PER_IO_OPERATION_DATA));       lpPerIOData->Buffer.len = MSGSIZE;       lpPerIOData->Buffer.buf = lpPerIOData->szMessage;       lpPerIOData->sClient = g_sNewClientConnection;             WSARecv(lpPerIOData->sClient,         &lpPerIOData->Buffer,         1,         &lpPerIOData->NumberOfBytesRecvd,         &lpPerIOData->Flags,         &lpPerIOData->overlap,         CompletionROUTINE);                  g_bNewConnectionArrived = FALSE;     }     SleepEx(1000, TRUE); } return 0; } void CALLBACK CompletionROUTINE(DWORD dwError,                                 DWORD cbTransferred,                                 LPWSAOVERLAPPED lpOverlapped,                                 DWORD dwFlags) { LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped; if (dwError != 0 || cbTransferred == 0) {     // Connection was closed by client    closesocket(lpPerIOData->sClient);    HeapFree(GetProcessHeap(), 0, lpPerIOData); } else {     lpPerIOData->szMessage[cbTransferred] = '/0';     send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);         // Launch another asynchronous operation     memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));     lpPerIOData->Buffer.len = MSGSIZE;     lpPerIOData->Buffer.buf = lpPerIOData->szMessage;        WSARecv(lpPerIOData->sClient,       &lpPerIOData->Buffer,       1,       &lpPerIOData->NumberOfBytesRecvd,       &lpPerIOData->Flags,       &lpPerIOData->overlap,       CompletionROUTINE); } } 用完成例程来实现重叠I/O比用事件通知简单得多。在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，就为那个客户端套接字激活一个异步的WSARecv操作，然后调用SleepEx使线程处于一种可警告的等待状态，以使得I/O完成后CompletionROUTINE可以被内核调用。如果辅助线程不调用SleepEx，则内核在完成一次I/O操作后，无法调用完成例程（因为完成例程的运行应该和当初激活WSARecv异步操作的代码在同一个线程之内）。 完成例程内的实现代码比较简单，它取出接收到的数据，然后将数据原封不动的发送给客户端，最后重新激活另一个WSARecv异步操作。注意，在这里用到了“尾随数据”。我们在调用WSARecv的时候，参数lpOverlapped实际上指向一个比它大得多的结构PER_IO_OPERATION_DATA，这个结构除了WSAOVERLAPPED以外，还被我们附加了缓冲区的结构信息，另外还包括客户端套接字等重要的信息。这样，在完成例程中通过参数lpOverlapped拿到的不仅仅是WSAOVERLAPPED结构，还有后边尾随的包含客户端套接字和接收数据缓冲区等重要信息。这样的C语言技巧在我后面介绍完成端口的时候还会使用到。 五.完成端口模型 “完成端口”模型是迄今为止最为复杂的一种I/O模型。然而，假若一个应用程序同时需要管理为数众多的套接字，那么采用这种模型，往往可以达到最佳的系统性能！但不幸的是，该模型只适用于Windows NT和Windows 2000操作系统。因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候，而且希望随着系统内安装的CPU数量的增多，应用程序的性能也可以线性提升，才应考虑采用“完成端口”模型。要记住的一个基本准则是，假如要为Windows NT或Windows 2000开发高性能的服务器应用，同时希望为大量套接字I/O请求提供服务（Web服务器便是这方面的典型例子），那么I/O完成端口模型便是最佳选择！（节选自《Windows网络编程》第八章） 完成端口模型是我最喜爱的一种模型。虽然其实现比较复杂（其实我觉得它的实现比用事件通知实现的重叠I/O简单多了），但其效率是惊人的。我在T公司的时候曾经帮同事写过一个邮件服务器的性能测试程序，用的就是完成端口模型。结果表明，完成端口模型在多连接（成千上万）的情况下，仅仅依靠一两个辅助线程，就可以达到非常高的吞吐量。下面我还是从代码说起： #include <WINSOCK2.H> #include <stdio.h> #define PORT    5150 #define MSGSIZE 1024 #pragma comment(lib, "ws2_32.lib") typedef enum { RECV_POSTED }OPERATION_TYPE; typedef struct { WSAOVERLAPPED overlap; WSABUF         Buffer; char           szMessage[MSGSIZE]; DWORD          NumberOfBytesRecvd; DWORD          Flags; OPERATION_TYPE OperationType; }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA; DWORD WINAPI WorkerThread(LPVOID); int main() { WSADATA                 wsaData; SOCKET                  sListen, sClient; SOCKADDR_IN             local, client; DWORD                   i, dwThreadId; int                     iaddrSize = sizeof(SOCKADDR_IN); HANDLE                  CompletionPort = INVALID_HANDLE_VALUE; SYSTEM_INFO             systeminfo; LPPER_IO_OPERATION_DATA lpPerIOData = NULL; // Initialize Windows Socket library WSAStartup(0x0202, &wsaData); // Create completion port CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); // Create worker thread GetSystemInfo(&systeminfo); for (i = 0; i < systeminfo.dwNumberOfProcessors; i++) {     CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId); } // Create listening socket sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); // Bind local.sin_addr.S_un.S_addr = htonl(INADDR_ANY); local.sin_family = AF_INET; local.sin_port = htons(PORT); bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN)); // Listen listen(sListen, 3); while (TRUE) {     // Accept a connection     sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);     printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));     // Associate the newly arrived client socket with completion port     CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);         // Launch an asynchronous operation for new arrived connection     lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(       GetProcessHeap(),       HEAP_ZERO_MEMORY,       sizeof(PER_IO_OPERATION_DATA));     lpPerIOData->Buffer.len = MSGSIZE;     lpPerIOData->Buffer.buf = lpPerIOData->szMessage;     lpPerIOData->OperationType = RECV_POSTED;     WSARecv(sClient,       &lpPerIOData->Buffer,       1,       &lpPerIOData->NumberOfBytesRecvd,       &lpPerIOData->Flags,       &lpPerIOData->overlap,       NULL); } PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL); CloseHandle(CompletionPort); closesocket(sListen); WSACleanup(); return 0; } DWORD WINAPI WorkerThread(LPVOID CompletionPortID) { HANDLE                  CompletionPort=(HANDLE)CompletionPortID; DWORD                   dwBytesTransferred; SOCKET                  sClient; LPPER_IO_OPERATION_DATA lpPerIOData = NULL; while (TRUE) {     GetQueuedCompletionStatus(       CompletionPort,       &dwBytesTransferred,       &sClient,       (LPOVERLAPPED *)&lpPerIOData,       INFINITE);     if (dwBytesTransferred == 0xFFFFFFFF)     {       return 0;     }         if (lpPerIOData->OperationType == RECV_POSTED)     {       if (dwBytesTransferred == 0)       {         // Connection was closed by client         closesocket(sClient);         HeapFree(GetProcessHeap(), 0, lpPerIOData);              }       else       {         lpPerIOData->szMessage[dwBytesTransferred] = '/0';         send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0);                 // Launch another asynchronous operation for sClient         memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));         lpPerIOData->Buffer.len = MSGSIZE;         lpPerIOData->Buffer.buf = lpPerIOData->szMessage;         lpPerIOData->OperationType = RECV_POSTED;         WSARecv(sClient,           &lpPerIOData->Buffer,           1,           &lpPerIOData->NumberOfBytesRecvd,           &lpPerIOData->Flags,           &lpPerIOData->overlap,           NULL);       }     } } return 0; } 首先，说说主线程： 1.创建完成端口对象 2.创建工作者线程（这里工作者线程的数量是按照CPU的个数来决定的，这样可以达到最佳性能） 3.创建监听套接字，绑定，监听，然后程序进入循环 4.在循环中，我做了以下几件事情： (1).接受一个客户端连接 (2).将该客户端套接字与完成端口绑定到一起(还是调用CreateIoCompletionPort，但这次的作用不同)，注意，按道理来讲，此时传递给CreateIoCompletionPort的第三个参数应该是一个完成键，一般来讲，程序都是传递一个单句柄数据结构的地址，该单句柄数据包含了和该客户端连接有关的信息，由于我们只关心套接字句柄，所以直接将套接字句柄作为完成键传递； (3).触发一个WSARecv异步调用，这次又用到了“尾随数据”，使接收数据所用的缓冲区紧跟在WSAOVERLAPPED对象之后，此外，还有操作类型等重要信息。 在工作者线程的循环中，我们 1.调用GetQueuedCompletionStatus取得本次I/O的相关信息（例如套接字句柄、传送的字节数、单I/O数据结构的地址等等） 2.通过单I/O数据结构找到接收数据缓冲区，然后将数据原封不动的发送到客户端 3.再次触发一个WSARecv异步操作 六.五种I/O模型的比较 我会从以下几个方面来进行比较 *有无每线程64连接数限制 如果在选择模型中没有重新定义FD_SETSIZE宏，则每个fd_set默认可以装下64个SOCKET。同样的，受MAXIMUM_WAIT_OBJECTS宏的影响，事件选择、用事件通知实现的重叠I/O都有每线程最大64连接数限制。如果连接数成千上万，则必须对客户端套接字进行分组，这样，势必增加程序的复杂度。 相反，异步选择、用完成例程实现的重叠I/O和完成端口不受此限制。 *线程数 除了异步选择以外，其他模型至少需要2个线程。一个主线程和一个辅助线程。同样的，如果连接数大于64，则选择模型、事件选择和用事件通知实现的重叠I/O的线程数还要增加。 *实现的复杂度 我的个人看法是，在实现难度上，异步选择<选择<用完成例程实现的重叠I/O<事件选择<完成端口<用事件通知实现的重叠I/O *性能 由于选择模型中每次都要重设读集，在select函数返回后还要针对所有套接字进行逐一测试，我的感觉是效率比较差；完成端口和用完成例程实现的重叠I/O基本上不涉及全局数据，效率应该是最高的，而且在多处理器情形下完成端口还要高一些；事件选择和用事件通知实现的重叠I/O在实现机制上都是采用WSAWaitForMultipleEvents，感觉效率差不多；至于异步选择，不好比较。所以我的结论是:选择<用事件通知实现的重叠I/O<事件选择<用完成例程实现的重叠I/O<完成端口