程序博客网 > 2008数据库管理软件

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

来源：互联网 发布：2008数据库管理软件 编辑：程序博客网 时间：2024/05/16 12:33
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语言技巧在我后面介绍完成端口的时候还会使用到。
2008数据库管理软件 2008数据库管理软件
原创粉丝点击
热门IT博客
网络推手怎么联系网络推手怎么联系
淘宝单品爆款技巧淘宝单品爆款技巧
婚庆后期制作软件
网络114可靠吗
php foo函数是什么意思
电信卡网络制式在哪
淘宝运费险退到哪里
破解无线网络密码软件
知乎 低价服务器
linux access函数
调到数据网接入设备
java开源网站有哪些
数据精灵破解版
java写文件换行
网络销售混底薪3个月
笑傲江湖ol知乎
淘宝号查询
纽约大学商学院知乎
杀出重围 知乎
mac能玩dota2吗
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 登录邮乐网 邮政邮乐网 邮乐网地址 www.邮乐网 邮乐网站 东部 东部华侨城 东部水晶塔 东部海滩 东部地区 东部瘟疫 东部客运站 东部锦龟 东部凹地 东部王国 东部圣殿 东部华侨城旅游 深圳东部华侨城 东部华侨城门票 内蒙古东部人才市场 东部华侨城攻略一日游 东部华侨城大侠谷 东部人才市场 东部华侨城大峡谷 美国东部时间 东部华侨城攻略 东部战区司令员李晓光 南京东部战区总医院 深圳东部华侨城大峡谷 东部水晶塔在什么位置 昆明东部客运站 东部华侨城哪个谷好玩 深圳东部华侨城门票 深圳东部预约通行 兰州东部批发市场 东部战区陆军司令员 宁波东部新城 东部水晶塔坐标 去东部华侨城要预约吗 东部吧 东部吧吧

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里