Socket I/O模型之重叠I/O(overlapped I/O)(转)

http://tangfeng.iteye.com/blog/518146

Winsock2的发布使得Socket I/O有了和文件I/O统一的接口。我们可以通过使用Win32文件操纵函数ReadFile和WriteFile来进行Socket I/O。伴随而来的，用于普通文件I/O的重叠I/O模型和完成端口模型对Socket I/O也适用了。这些模型的优点是可以达到更佳的系统性能，但是实现较为复杂，里面涉及较多的C语言技巧。例如我们在完成端口模型中会经常用到所谓的“尾随数据”。 

一、用事件通知方式实现的重叠I/O 模型 

C++代码   收藏代码
  1. // write by larry  
  2. // 2009-8-20  
  3. // This is a server using overlapped IO(event notify).  
  4. #include "stdafx.h"  
  5. #include <WINSOCK2.H>  
  6. #include <stdio.h>  
  7. #pragma comment(lib, "ws2_32.lib")  
  8. #define PORT  5150  
  9. #define MSGSIZE  1024  
  10. typedef struct   
  11. {  
  12.     WSAOVERLAPPED overlap;  
  13.     WSABUF        Buffer;  
  14.     char          szMessage[MSGSIZE];  
  15.     DWORD         NumberOfBytesRecvd;  
  16.     DWORD         Flags;  
  17. } PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;  
  18. int                     g_iTotalConn = 0;  
  19. SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];  
  20. WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];  
  21. LPPER_IO_OPERATION_DATA g_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];  
  22. DWORD WINAPI WorkerThread(LPVOID lpParam);  
  23. void Cleanup(int index);  
  24.   
  25. int main(int argc, char* argv[])  
  26. {  
  27.     WSADATA wsaData;  
  28.     SOCKET sListen, sClient;  
  29.     SOCKADDR_IN local, client;  
  30.     DWORD dwThreadId;  
  31.     int iAddrSize = sizeof(SOCKADDR_IN);  
  32.     // Initialize windows socket library  
  33.     WSAStartup(0x0202, &wsaData);  
  34.     // Create listening socket  
  35.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
  36.     // Bind  
  37.     local.sin_family = AF_INET;  
  38.     local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);  
  39.     local.sin_port = htons(PORT);  
  40.     bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));  
  41.     // Listen  
  42.     listen(sListen, 3);  
  43.     // Create worker thread  
  44.     CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);  
  45.     while (TRUE)  
  46.     {  
  47.         // Accept a connection  
  48.         sClient = accept(sListen, (sockaddr*)&client, &iAddrSize);  
  49.         printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));        
  50.         g_CliSocketArr[g_iTotalConn] = sClient;  
  51.         // Associate a PER_IO_OPERATION_DATA structure  
  52.         g_pPerIoDataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(  
  53.             GetProcessHeap(),  
  54.             HEAP_ZERO_MEMORY,  
  55.             sizeof(PER_IO_OPERATION_DATA));  
  56.         g_pPerIoDataArr[g_iTotalConn]->Buffer.len = MSGSIZE;  
  57.         g_pPerIoDataArr[g_iTotalConn]->Buffer.buf = g_pPerIoDataArr[g_iTotalConn]->szMessage;  
  58.         g_CliEventArr[g_iTotalConn] = g_pPerIoDataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();  
  59.         // Launch an asynchronous operation  
  60.         WSARecv(g_CliSocketArr[g_iTotalConn],  
  61.             &g_pPerIoDataArr[g_iTotalConn]->Buffer,  
  62.             1,  
  63.             &g_pPerIoDataArr[g_iTotalConn]->NumberOfBytesRecvd,  
  64.             &g_pPerIoDataArr[g_iTotalConn]->Flags,  
  65.             &g_pPerIoDataArr[g_iTotalConn]->overlap,  
  66.             NULL);  
  67.         g_iTotalConn++;  
  68.     }  
  69.       
  70.     closesocket(sListen);  
  71.     WSACleanup();  
  72.     return 0;  
  73. }  
  74. DWORD WINAPI WorkerThread(LPVOID lpParam)  
  75. {  
  76.     int ret, index;  
  77.     DWORD cbTransferred;  
  78.     while (TRUE)  
  79.     {  
  80.         ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);  
  81.         if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)  
  82.         {  
  83.             continue;  
  84.         }  
  85.         index = ret - WSA_WAIT_EVENT_0;  
  86.         WSAResetEvent(g_CliEventArr[index]);  
  87.         WSAGetOverlappedResult(g_CliSocketArr[index],  
  88.             &g_pPerIoDataArr[index]->overlap,  
  89.             &cbTransferred,  
  90.             TRUE,  
  91.             &g_pPerIoDataArr[g_iTotalConn]->Flags);  
  92.         if (cbTransferred == 0)  
  93.         {  
  94.             // The connection was closed by client  
  95.             Cleanup(index);  
  96.         }  
  97.         else  
  98.         {  
  99.             // g_pPerIoDataArr[index]->szMessage contains the recvived data  
  100.             g_pPerIoDataArr[index]->szMessage[cbTransferred] = '\0';  
  101.             send(g_CliSocketArr[index], g_pPerIoDataArr[index]->szMessage, cbTransferred, 0);  
  102.             // Launch another asynchronous operation  
  103.             WSARecv(g_CliSocketArr[index],  
  104.                 &g_pPerIoDataArr[index]->Buffer,  
  105.                 1,  
  106.                 &g_pPerIoDataArr[index]->NumberOfBytesRecvd,  
  107.                 &g_pPerIoDataArr[index]->Flags,  
  108.                 &g_pPerIoDataArr[index]->overlap,  
  109.                 NULL);  
  110.         }  
  111.     }  
  112.       
  113.     return 0;  
  114. }  
  115. void Cleanup(int index)  
  116. {  
  117.     closesocket(g_CliSocketArr[index]);  
  118.     WSACloseEvent(g_CliEventArr[index]);  
  119.     HeapFree(GetProcessHeap(), 0, g_pPerIoDataArr[index]);  
  120.     if (index < g_iTotalConn-1)  
  121.     {  
  122.         g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn-1];  
  123.         g_CliEventArr[index] = g_CliEventArr[g_iTotalConn-1];  
  124.         g_pPerIoDataArr[index] = g_pPerIoDataArr[g_iTotalConn-1];  
  125.     }  
  126.       
  127.     g_pPerIoDataArr[--g_iTotalConn] = NULL;  
  128. }  

这个模型与上述其他模型不同的是它使用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异步操作。 

二、 用完成例程方式实现的重叠I/O 模型 
C++代码   收藏代码
  1. // write by larry  
  2. // 2009-8-20  
  3. // This is a server using overlapped IO(completion routine).  
  4. #include "stdafx.h"  
  5. #include <WINSOCK2.H>  
  6. #include <stdio.h>  
  7. #pragma comment(lib, "ws2_32.lib")  
  8. #define PORT  5150  
  9. #define MSGSIZE  1024  
  10. typedef struct   
  11. {  
  12.     WSAOVERLAPPED overlap;  
  13.     WSABUF        Buffer;  
  14.     char          szMessage[MSGSIZE];  
  15.     DWORD         NumberOfBytesRecvd;  
  16.     DWORD         Flags;  
  17.     SOCKET        sClient;  
  18. } PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;  
  19. int                     g_iTotalConn = 0;  
  20. SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];  
  21. WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];  
  22. LPPER_IO_OPERATION_DATA g_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];  
  23. DWORD WINAPI WorkerThread(LPVOID lpParam);  
  24. void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);  
  25. SOCKET g_sNewClientConnection;  
  26. BOOL g_bNewConnectionArrived = FALSE;  
  27.   
  28. int main(int argc, char* argv[])  
  29. {  
  30.     WSADATA wsaData;  
  31.     SOCKET sListen;  
  32.     SOCKADDR_IN local, client;  
  33.     DWORD dwThreadId;  
  34.     int iAddrSize = sizeof(SOCKADDR_IN);  
  35.     // Initialize windows socket library  
  36.     WSAStartup(0x0202, &wsaData);  
  37.     // Create listening socket  
  38.     sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
  39.     // Bind  
  40.     local.sin_family = AF_INET;  
  41.     local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);  
  42.     local.sin_port = htons(PORT);  
  43.     bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));  
  44.     // Listen  
  45.     listen(sListen, 3);  
  46.     // Create worker thread  
  47.     CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);  
  48.     while (TRUE)  
  49.     {  
  50.         // Accept a connection  
  51.         g_sNewClientConnection = accept(sListen, (sockaddr*)&client, &iAddrSize);  
  52.         g_bNewConnectionArrived = TRUE;  
  53.         printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));        
  54.     }  
  55.     return 0;  
  56. }  
  57. DWORD WINAPI WorkerThread(LPVOID lpParam)  
  58. {  
  59.     LPPER_IO_OPERATION_DATA lpPerIOData = NULL;  
  60.     while (TRUE)  
  61.     {  
  62.         if (g_bNewConnectionArrived)  
  63.         {  
  64.             // Launch an asynchronous operation for new arrived connection  
  65.             lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(  
  66.                 GetProcessHeap(),  
  67.                 HEAP_ZERO_MEMORY,  
  68.                 sizeof(PER_IO_OPERATION_DATA));  
  69.             lpPerIOData->Buffer.len = MSGSIZE;  
  70.             lpPerIOData->Buffer.buf = lpPerIOData->szMessage;  
  71.             lpPerIOData->sClient = g_sNewClientConnection;  
  72.             WSARecv(lpPerIOData->sClient,  
  73.                 &lpPerIOData->Buffer,  
  74.                 1,  
  75.                 &lpPerIOData->NumberOfBytesRecvd,  
  76.                 &lpPerIOData->Flags,  
  77.                 &lpPerIOData->overlap,  
  78.                 CompletionRoutine);  
  79.             g_bNewConnectionArrived = FALSE;  
  80.         }  
  81.         SleepEx(1000, TRUE);  
  82.     }  
  83.     return 0;  
  84. }  
  85. void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)  
  86. {  
  87.     LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;  
  88.     if (dwError != 0 || cbTransferred == 0)  
  89.     {  
  90.         // Connection was closed by client  
  91.         closesocket(lpPerIOData->sClient);  
  92.         HeapFree(GetProcessHeap(), 0, lpPerIOData);  
  93.     }  
  94.     else  
  95.     {  
  96.         lpPerIOData->szMessage[cbTransferred] = '\0';  
  97.         send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);  
  98.         // Launch another asynchronous operation  
  99.         memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));  
  100.         lpPerIOData->Buffer.len = MSGSIZE;  
  101.         lpPerIOData->Buffer.buf = lpPerIOData->szMessage;  
  102.         WSARecv(lpPerIOData->sClient,  
  103.             &lpPerIOData->Buffer,  
  104.             1,  
  105.             &lpPerIOData->NumberOfBytesRecvd,  
  106.             &lpPerIOData->Flags,  
  107.             &lpPerIOData->overlap,  
  108.             CompletionRoutine);  
  109.     }  
  110. }  

用完成例程来实现重叠I/O比用事件通知简单得多。在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，就为那个客户端套接字激活一个异步的WSARecv操作，然后调用SleepEx使线程处于一种可警告的等待状态，以使得I/O完成后 CompletionROUTINE可以被内核调用。如果辅助线程不调用SleepEx，则内核在完成一次I/O操作后，无法调用完成例程（因为完成例程的运行应该和当初激活WSARecv异步操作的代码在同一个线程之内）。 

完成例程内的实现代码比较简单，它取出接收到的数据，然后将数据原封不动的发送给客户端，最后重新激活另一个WSARecv异步操作。注意，在这里用到了 “尾随数据”。我们在调用WSARecv的时候，参数lpOverlapped实际上指向一个比它大得多的结构 PER_IO_OPERATION_DATA，这个结构除了WSAOVERLAPPED以外，还被我们附加了缓冲区的结构信息，另外还包括客户端套接字等重要的信息。这样，在完成例程中通过参数lpOverlapped拿到的不仅仅是WSAOVERLAPPED结构，还有后边尾随的包含客户端套接字和接收数据缓冲区等重要信息。这样的C语言技巧在我后面介绍完成端口的时候还会使用到。
posted @ 2011-06-28 10:25  董雨  阅读(295)  评论(0)  编辑  收藏  举报