重叠模型的基本设计原理是让应用程序使用重叠的数据结构，一次投递一个或多个WinsockI/O请求。针对那些提交的请求，在它们完成之后，应用程序可为它们提供服务。模型的总体设计以Windows重叠I/O机制为基础。这个机制可通过ReadFile和WriteFile两个函数，在设备上执行I/O操作。

要想在一个套接字上使用重叠I/O模型，首先必须创建一个设置了重叠标志的套接字。

主要有两种方法来管理重叠I/O的请求。1.事件对象通知 2.完成实例。

事件通知：

重叠I/O的事件通知方法要求将Windows事件对象与WSAOVERLAPPED结构关联在一起。若使用一个WSAOVERLAPPED结构，发出像WSASend和WSARecv这样的I/O调用，它们会立即返回。

WSAOVERLAPPED结构为重叠I/O请求的初始化及其后续的完成之间提供了一种通信媒介。结构的定义如下：

1. typedef struct WSAOVERLAPPED
2. {
3. DWORD Internal;
4. DWORD InternalHigh;
5. DWORD Offset;
6. DWORD OffsetHigh;
7. WSAEVENT hEvent;
8. }WSAOVERLAPPED, FAR* LPWSAOVERLAPPED;

Internal,InternalHigh,Offset,OffsetHigh字段均由系统在内部使用，不能有应用程序直接进行处理或使用。hEvent字段则允许应用程序将事件对象的句柄同操作关联起来。

一个重叠I/O完成以后，应用程序要负责获取重叠I/O操作的结果。一个重叠请求操作最终完成之后，在事件通知方法中，Winsock会更改与WSAOVERLAPPED结构关联的事件对象的事件传信状态，将未传信变成已传信。由于已经有一个事件对象分配给WSAOVERLAPPED结构，所有只需简单的调用WSAWaitForMultipleEvents函数，便可判断出重叠I/O调用将在什么时候完成。WSAWaitForMultipleEvents会等待一段指定时间，等待一个或多个事件进入已传信状态。 WSAWaitForMultipleEvents一次只能等待64个事件对象。确定某个重叠事件完成以后，接着需要调用WSAGetOverlappedResult函数，判断这个重叠调用是否成功。

1. BOOL WSAGetOverlappedResult(
2. SOCKET s, //重叠操作开始的时候，被指定的套接字
3. LPWSAOVERLAPPED lpOverlapped, //重叠操作开始的时候，被指定的WSAOVERLAPPED结构
4. LPDWORD lpcbTransfer,//负责接收一次重叠发送或接收操作实际传输的字节数
5. BOOL fWait,//用于决定函数是否应该等待挂起的重叠操作完成
6. LPWORD lpdwFlags //负责接收结果标志
7. );

若WSAGetOverlappedResult函数调用成功，返回值就是TRUE，意味着重叠操作完成成功，而且lpcbTransfer参数所指向的值已进行了更新，若返回FALSE，那么可能是由以下原因造成的：

1.重叠I/O操作仍处于挂起状态

2.重叠操作已经完成，但含有错误

3.因为在提供给WSAGetOverlappedResult函数的一个或多个参数中存在错误，所有无法判断重叠操作的完成状态

失败后，lpcbTransfer所指向的值不会被更新，而且应用程序应调用WSAGetLastError函数查看错误原因。

利用事件通知机制设计一个简单的服务器应用程序，令其在一个套接字上对重叠I/O操作进行管理：

1. #define DATA_BUFSIZE 2046
2. void main(void)
3. {
4. WSABUF DataBuf;
5. char buffer[DATA_BUFSIZE];
6. DWORD EventTotal = 0;
7. DWORD RecvBytes = 0;
8. DWORD Flags = 0;
9. WSAEVENT EventArray[WSA_MAXIMUM_WAIT_EVENTS];
10. WSAOVERLAPPED AcceptOverlapped;
11. SOCKET ListenSocket, AcceptSocket;
12. //第一步
13. //启动Winsock，建立监听套接字
14. ...
15. //第二步
16. //接收一个入站连接
17. AcceptSocket = accept(ListenSocket,NULL,NULL);
18. //第三步
19. //建立一个重叠结构
20. EventArray[EventTotal] = WSACreateEvent();
21. ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));
22. AcceptOverlapped.hEvent = EventArray[EventTotal];
23. DataBuf.len = DATA_BUFSIZE;
24. DataBuf.buf = buffer;
25. EventTotal++;
26. //第四步
27. //接收一个WSARecv请求，以便在套接字上接收数据
28. if(SOCKET_ERROR ==
29. WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL))
30. {
31. if(WSA_IO_PENDING != WSAGetLastError())
32. {
33. //出错
34. }
35. }
36. //处理套件子上的重叠接收
37. while(TRUE)
38. {
39. DWORD Index;
40. //第五步
41. //等候重叠I/O调用结束
42. Index = WSAWaitForMultipleEvents(EventTotal, EventArray, FALSE, WSA_INFINITE, FALSE);
43. //索引应为0，因为EventArray中仅有一个事件
44. //第六步
45. //重置已传信事件
46. WSAResetEvent(EventArray[Index-WSA_WAIT_EVENT_0]);
47. //第七步
48. //确定重叠请求的状态
49. WSAGetOverlappedResult(AcceptSocket,&AcceptOverlapped,&BytesTransferred,FALSE,&Flags);
50. //先 检查看通信对方是否已经关闭连接，如果关闭，则关闭套接字
51. if(BytesTransferred==0)
52. {
53. printf("Closing socket %d\n", AcceptSocket);
54. closesocket(AcceptSocket);
55. WSACloseEvent(EventArray[Index-WSA_WAIT_EVENT_0]);
56. return ;
57. }
58. //对接收到的数据进行某种处理
59. //DataBuf包含接收到的数据
60. ...
61. //第八步
62. //在套接字上投递另一个WSARecv请求
63. Flags = 0;
64. ZeroMemory(&AccpetOverlapped, sizeof(WSAOVERLAPPED));
65. AcceptOverlapped.hEvent = EventArray[Index-WSA_WAIT_EVENT_0];
66. DataBuf.len = DATA_BUFSIZE;
67. DataBuf.buf = buffer;
68. if(SOCKET_ERROR ==
69. WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &AcceptOverlapped, NULL))
70. {
71. if(WSA_IO_PENDING != WSAGetLastError())
72. {
73. //出错
74. }
75. }
76. }
77. }

对该程序采用的编程步骤总结如下：

1.创建一个套接字，开始在指定的端口上监听连接请求

2.接受一个入站的连接请求

3.为接收的套接字新建一个WSAOVERLAPPED结构，并为该结构分配一个事件对象句柄。也将该事件对象句柄分配给一个事件数组，以便稍后由WSAWaitForMultipleEvents使用。

4.将WSAOVERLAPPED指定为参数，在套接字上投递一个异步WSARecv请求

5.使用步骤3的事件数组，调用WSAWaitForMultipleEvents函数，并等待与重叠调用关联在一起的事件进入已传信状态

6.使用WSAGetOverlappedResult函数，判断重叠调用的返回状态

7.函数完成后，针对重叠数组，调用WSAResetEvent函数，从而重设事件对象，并对完成的重叠请求进行处理

8.在套接字上投递另一个重叠WSARecv请求

9.重复步骤5～8

这个例子极易扩展，从而提供对多个套接字的支持。方法是将代码的重叠I/O处理部分移至一个对立的线程中，让主应用程序线程为额外的连接请求提供服务。

===================================================================

1. #include<winsock2.h>
2. #include<stdio.h>
3. #pragma comment(lib,"ws2_32.lib");
4. #define PORT 5050
5. #define MSGSIZE 1024
6. typedef struct
7. {
8. WSAOVERLAPPED overlap;
9. WSABUF Buffer;
10. char szMessage[MSGSIZE];
11. DWORD NumberOfBytesRecvd;
12. DWORD Flags;
13. }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;
14. int                     g_iTotalConn = 0;
15. SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
16. WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
17. LPPER_IO_OPERATION_DATA g_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];
18. DWORD WINAPI WorkerThread(LPVOID lpParam);
19. void Cleanup(int index);
20. int main()
21. {
22. WSADATA wsaData;
23. SOCKET sListen, sClient;
24. SOCKADDR_IN client, local;
25. DWORD dwThreadId;
26. int iAddrSize = sizeof(SOCKADDR_IN);
27. WSAStartup(MAKEWORD(2,2), &wsaData);
28. sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
29. memset(&local, 0, sizeof(SOCKADDR_IN));
30. local.sin_family = AF_INET;
31. local.sin_port = htons(PORT);
32. local.sin_addr.s_addr = htonl(INADDR_ANY);
33. bind(sListen, (SOCKADDR*)&local, sizeof(SOCKADDR_IN));
34. listen(sListen, 5);
35. CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
36. while(TRUE)
37. {
38. sClient = accept(sListen, (SOCKADDR*)&client, &iAddrSize);
39. printf("Accepted Client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
40. g_CliSocketArr[g_iTotalConn] = sClient;
41. g_pPerIoDataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(
42. GetProcessHeap(),
43. HEAP_ZERO_MEMORY,
44. sizeof(PER_IO_OPERATION_DATA)
45. );
46. g_pPerIoDataArr[g_iTotalConn]->Buffer.len = MSGSIZE;
47. g_pPerIoDataArr[g_iTotalConn]->Buffer.buf = g_pPerIoDataArr[g_iTotalConn]->szMessage;
48. g_pPerIoDataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();
49. g_CliEventArr[g_iTotalConn] = g_pPerIoDataArr[g_iTotalConn]->overlap.hEvent;
50. WSARecv(g_CliSocketArr[g_iTotalConn],
51. &g_pPerIoDataArr[g_iTotalConn]->Buffer,
52. 1,
53. &g_pPerIoDataArr[g_iTotalConn]->NumberOfBytesRecvd,
54. &g_pPerIoDataArr[g_iTotalConn]->Flags,
55. &g_pPerIoDataArr[g_iTotalConn]->overlap,
56. NULL);
57. g_iTotalConn++;
58. }
59. closesocket(sListen);
60. WSACleanup();
61. return 0;
62. }
63. DWORD WINAPI WorkerThread(LPVOID lpParam)
64. {
65. int ret, index;
66. DWORD cbTransferred;
67. while(TRUE)
68. {
69. ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
70. if(ret==WSA_WAIT_FAILED || ret==WSA_WAIT_TIMEOUT)
71. {
72. //如果当前没有客户端的话，要sleep一下，要不然CUP会占50%以上
73. if(g_iTotalConn==0)
74. Sleep(1000);
75. continue;
76. }
77. index = ret - WSA_WAIT_EVENT_0;
78. WSAResetEvent(g_CliEventArr[index]);
79. WSAGetOverlappedResult(g_CliSocketArr[index],
80. &g_pPerIoDataArr[index]->overlap,
81. &cbTransferred,
82. TRUE,
83. &g_pPerIoDataArr[index]->Flags);
84. if(cbTransferred==0)
85. {
86. Cleanup(index);
87. }
88. else
89. {
90. g_pPerIoDataArr[index]->szMessage[cbTransferred] = '\0';
91. send(g_CliSocketArr[index],g_pPerIoDataArr[index]->szMessage,cbTransferred,0);
92. WSARecv(g_CliSocketArr[index],
93. &g_pPerIoDataArr[index]->Buffer,
94. 1,
95. &g_pPerIoDataArr[index]->NumberOfBytesRecvd,
96. &g_pPerIoDataArr[index]->Flags,
97. &g_pPerIoDataArr[index]->overlap,
98. NULL);
99. }
100. }
101. return 0;
102. }
103. void Cleanup(int index)
104. {
105. closesocket(g_CliSocketArr[index]);
106. WSACloseEvent(g_CliEventArr[index]);
107. HeapFree(GetProcessHeap(), 0, g_pPerIoDataArr[index]);
108. if(index<g_iTotalConn-1)
109. {
110. g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn-1];
111. g_CliEventArr[index] = g_CliEventArr[g_iTotalConn-1];
112. g_pPerIoDataArr[index] = g_pPerIoDataArr[g_iTotalConn-1];
113. }
114. g_pPerIoDataArr[--g_iTotalConn] = NULL;
115. }

完成例程：

完成例程是应用程序用来管理完成的重叠I/O请求的另一种方法。完成例程其实就是一些函数，我们将这些函数传递给重叠I/O请求，以供重叠I/O请求完成时由系统调用。它们的设计宗旨，是通过调用者的线程，为已完成的I/O请求提供服务。除此以外，应用程序可通过完成例程，继续进行重叠I/O的处理。

如果希望用完成例程为重叠I/O请求提供服务，应用程序必须为一个绑定I/O的Winsock函数指定一个完成例程，同时指定一个WSAOVERLAPPED结构。一个完成例程必须拥有下述函数原型：

1. void CALLBACK CompletionROUTINE(
2. DWORD dwError,
3. DWORD cbTransferred,
4. LPWSAOVERLAPPED lpOverlapped,
5. DWORD dwFlags
6. );

1.dwError参数表明一个重叠操作的完成状态时什么

2.cbTransferred参数指明了在重叠操作期间，实际传输的字节量是多大

3.lpOverlapped参数指明传递到最初的I/O调用内的一个WSAOVERLAPPED结构

4.dwFlags参数返回操作结束时可能用的标志

在用一个完成例程提交的重叠请求与用一个事件对象提交的重叠请求之间，存在着一个非常重要的区别。WSAOVERLAPPED的hEvent并未被使用，也就是说，不可以将一个事件对象同重叠请求关联在一起。用完成例程发出重叠I/O调用之后，调用线程一旦完成，最终必须为完成例程提供服务。这样，便要求我们将调用线程置于一种警觉等待状态。并在I/O操作完成后，对完成例程加以处理。WSAWaitForMultipleEvents可以将线程置于一种警觉的等待状态。这样做的缺点在于，我们必须还有一个事件对象可用于WSAWaitForMultipleEvents函数。假定应用程序用完成例程只对重叠请求进行处理，便不大可能有什么事件对象需要处理。作为一种变通方法，应用程序可用SleepEx函数将线程置于一种警觉的等待状态。当然，也可创建一个伪事件对象，它不与任何东西关联在一起。假如调用线程总是处于繁忙状态，而不是处于一种警觉的等待状态，那么根本不会有被投递的完成例程会得到调用。

WSAWaitForMultipleEvents通常会等待同WSAOVERLAPPED关联在一起的事件对象。该函数也用来将线程置于一种警觉的等待状态，并可为已经完成的重叠I/O请求进行完成例程的处理（前提是将fAlertable设为TRUE）。用完成例程接收重叠I/O请求之后，返回值是WSA_IO_COMPLETION，而不是事件数组中的一个事件对象的索引。SleepEx实际上和WSAWaitForMultipleEvents差不多，只是它不需要事件对象。

1. DWORD SleepEx(
2. DWORD dwMilliseconds,
3. BOOL bAlertable
4. );

dwMilliseconds定义了SleepEx函数的等待时间，以毫秒为单位，如果将dwMilliseconds设为INFINITE，那么SleepEx会无休止的等待下去。

bAlertable指定了完成例程的执行方式。假如将bAlertable设为FALSE，而且进行了一次I/O完成回叫，那么I/O完成函数就不会执行，而且该函数也不会返回。除非超过由dwMilliseconds规定的时间。若设为TRUE，那么完成例程便会得到执行，同时SleepEx函数返回WAIT_IO_COMPLETION。

下面代码演示了如果构建一个简单的服务器应用程序，令其采用前述方法，通过完成例程来实现对一个套接字请求管理：

1. #define DATA_BUFSIZE 4096
2. SOCKET AcceptSocket, ListenSocket;
3. WSABUF DataBuf;
4. char buffer[DATA_BUFSIZE];
5. WSAEVENT EventArray[MAXIMUM_WAIT_OBJECTS];
6. DWORD Flags, RecvBytes, Index;
7. void main(void)
8. {
9. WSAOVERLAPPED Overlapped;
10. //第一步
11. //启动Winsock，建立监听套接字
12. ...
13. //第二步
14. //接受一个新连接
15. AcceptSocket = accept(ListenSocket, NULL, NULL);
16. //第三步
17. //已经有一个接收套接字之后，开始使用带有完成例程的重叠I/O来处理I/O
18. //为了启动重叠I/O处理，先提交一个重叠WSARecv请求
19. Flags = 0;
20. ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));
21. DataBuf.len = DATA_BUFSIZE;
22. DataBuf.buf = buffer;
23. //第四步
24. //将WSAOVERLAPPED结构指定为一个参数，在套接字上投递一个异步WSARecv请求并提供下面的
25. //作为完成例程的WorkerRoutine函数
26. if(SOCKET_ERROR = WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &Overlapped, WorkerRoutine))
27. {
28. if(WSA_IO_PENDING != WSAGetLastError())
29. {
30. printf("WSARecv() failed with error %d\n", WSAGetLastError());
31. return ;
32. }
33. }
34. //因为WSAWaitForMultipleEvents()API要求在一个或多个事件对象上等待，
35. //因此不得不创建一个伪事件对象。作为一种可选方案，也可使用SleepEx作为替代
36. EventArray[0] = WSACreateEvent();
37. while(TRUE)
38. {
39. //第五步
40. Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, WSA_INFINITE, TRUE);
41. //第六步
42. if(Index==WSA_IO_COMPLETION)
43. {
44. //一个重叠请求完成例程结束，继续为更多的完成例程服务
45. continue;
46. }
47. else
48. {
49. //发生一个错误，停止处理
50. //如果正在处理一个事件对象，那么这也就可能是事件数组的一个索引
51. return ;
52. }
53. }
54. }
55. void CALLBACK WorkerRoutine(DWORD Error, DWORD BytesTransferred,
56. LPWSAOVERLAPPED Overlapped, DWORD InFlags)
57. {
58. DWORD RecvBytes, SendBytes;
59. DWORD Flags;
60. if(Error!=0||BytesTransferred==0)
61. {
62. //要么是套接字上发生了一个错误，要么套接字已经被通信对方关闭
63. closesocket(AcceptSocket);
64. return ;
65. }
66. //此刻，一个重叠的WSARecv请求顺利完成
67. //现在可接收DataBuf变量中包含的已接收的数据了
68. //处理完接收到的数据后，需要投递另外一个重叠的WSARecv或WSASend请求
69. //为简便起见，这里投递另外一个WSARecv请求
70. Flags = 0;
71. ZeroMemory(&Overlapped, sizeof(WSAOVERLAPPED));
72. DataBuf.len = DATA_BUFSIZE;
73. DataBuf.buf = buffer;
74. if(SOCKET_ERROR = WSARecv(AcceptSocket, &DataBuf, 1, &RecvBytes, &Flags, &Overlapped, WorkerRoutine))
75. {
76. if(WSA_IO_PENDING != WSAGetLastError())
77. {
78. printf("WSARecv() failed with error %d\n", WSAGetLastError());
79. return ;
80. }
81. }
82. }

程序主要的执行步骤：

1.新建一个套接字，开始在指定端口上监听传入的连接

2.接收一个入站连接

3.为接收的套接字创建一个WSAOVERLAPPED结构

4.在套接字上投递一个异步WSARecv请求，需要将WSAOVERLAPPED指定为一个参数，同时提供一个完成例程

5.在将fAlertable设为TRUE的前提下，调用WSAWaitForMultipleEvents，并等待一个重叠I/O请求完成。重叠请求完成后，完成例程会自动执行，而且WSAWaitForMultipeEvents会返回一个WSA_IO_COMPLETION。在完成例程内，可用一个完成例程投递另一个重叠WSARecv请求。

6.检查WSAWaitForMultipleEvents是否返回WSA_IO_COMPLETION

7.重复步骤5～6

重叠模型提供高性能的套接字I/O，因为使用这种模型的应用程序通知缓冲区收发系统直接使用的数据，所有跟前面几种不同。也就是说，如果应用程序投递了一个10KB大小的缓冲区来接收数据，且数据已到达套接字，则该数据将直接被拷贝到投递的缓冲区。在前述模型中，数据到达并被拷贝到单套接字接收缓冲区中，此时应用程序会被告知可以读入的容量。当应用程序调用接收函数之后，数据将从单套接字缓冲区拷贝到应用程序的缓冲区。

在事件中使用重叠I/O的缺点，也就是每次最多只能等待64个事件这一局限性。完成例程是一个不错的替代方案，但必须注意确保投递完成操作的线程进入警觉的等待状态，以便使完成例程能够圆满的结束。同时，还要确保完成例程不要做过量的运算，以便在很重的负载之下，这些完成过程能够尽快开始运行。

=============================================================

1. #include <stdio.h>
2. #include <Winsock2.h>
3. #pragma comment(lib, "ws2_32.lib")
4. #define PORT 5050
5. #define MSGSIZE 1024
6. typedef struct
7. {
8. WSAOVERLAPPED overlap;
9. WSABUF Buffer;
10. char szMessage[MSGSIZE];
11. DWORD NumberOfBytesRecvd;
12. DWORD Flags;
13. SOCKET sClient;
14. }PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;
15. int                     g_iTotalConn = 0;
16. SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
17. WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
18. LPPER_IO_OPERATION_DATA g_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];
19. SOCKET g_sNewClientConnection = NULL;
20. BOOL g_bNewConnectionArrived = FALSE;
21. DWORD WINAPI WorkerThread(LPVOID lpParam);
22. void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred,
23. LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);
24. int main()
25. {
26. WSADATA wsaData;
27. SOCKET sListen;
28. SOCKADDR_IN local, client;
29. int iAddrSize = sizeof(SOCKADDR_IN);
30. DWORD dwThreadId;
31. WSAStartup(MAKEWORD(2,2), &wsaData);
32. sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
33. memset(&local, 0, sizeof(SOCKADDR_IN));
34. local.sin_family = AF_INET;
35. local.sin_port = htons(PORT);
36. local.sin_addr.s_addr = htonl(INADDR_ANY);
37. bind(sListen, (SOCKADDR*)&local, sizeof(SOCKADDR_IN));
38. listen(sListen, 5);
39. CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
40. while(TRUE)
41. {
42. g_sNewClientConnection = accept(sListen, (SOCKADDR*)&client, &iAddrSize);
43. g_bNewConnectionArrived = TRUE;
44. printf("Accepted Client:%s:%d \n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
45. }
46. return 0;
47. }
48. DWORD WINAPI WorkerThread(LPVOID lpParam)
49. {
50. LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
51. while(TRUE)
52. {
53. if(g_bNewConnectionArrived)
54. {
55. lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
56. GetProcessHeap(),
57. HEAP_ZERO_MEMORY,
58. sizeof(PER_IO_OPERATION_DATA));
59. lpPerIOData->Buffer.len = MSGSIZE;
60. lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
61. lpPerIOData->sClient = g_sNewClientConnection;
62. WSARecv(lpPerIOData->sClient,
63. &lpPerIOData->Buffer,
64. 1,
65. &lpPerIOData->NumberOfBytesRecvd,
66. &lpPerIOData->Flags,
67. &lpPerIOData->overlap,
68. CompletionRoutine);
69. g_bNewConnectionArrived = FALSE;
70. }
71. SleepEx(1000,TRUE);
72. }
73. return 0;
74. }
75. void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred,
76. LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)
77. {
78. LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;
79. if(dwError!=0||cbTransferred==0)
80. {
81. closesocket(lpPerIOData->sClient);
82. HeapFree(GetProcessHeap(),0,lpPerIOData);
83. }
84. else
85. {
86. lpPerIOData->szMessage[cbTransferred] = '\0';
87. send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);
88. memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));
89. lpPerIOData->Buffer.len = MSGSIZE;
90. lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
91. WSARecv(lpPerIOData->sClient,
92. &lpPerIOData->Buffer,
93. 1,
94. &lpPerIOData->NumberOfBytesRecvd,
95. &lpPerIOData->Flags,
96. &lpPerIOData->overlap,
97. CompletionRoutine);
98. }
99. }

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

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

套接字I/O模型-重叠I/O相关推荐

1. 套接字I/O模型之WSAEventSelect

   今天我又学习了一种新的套接字I/O模型------WSAEventSelect,他与WSAAsyncSelect一样也是一种异步事件通知模型,不同的是WSAAsyncSelect是与窗口句柄关联在一起 ...

2. Windsock套接字I/O模型学习 --- 第二章

   1. select模型 select模型主要借助于apiselect来实现,所以先介绍一下select函数 int select( int nfds, // 忽略,仅是为了与 Berkeley 套接字 ...

3. 套接字I/O模型-WSAEventSelect（转载）

   和WSAAsyncSelect类似,它也允许应用程序在一个或多个套接字上,接收以事件为基础的网络事件通知. 该模型最主要的区别是在于网络事件是由对象句柄完成的,而不是通过窗口例程完成.事件通知 事件通 ...

4. 套接字 I/O 模型 WSAEvent

   和WSAAsyncSelect类似,它也允许应用程序在一个或多个套接字上,接收以事件为基础的网络事件通知. 该模型最主要的区别是在于网络事件是由对象句柄完成的,而不是通过窗口例程完成. 事件通知 事件 ...

5. 套接字I/O模型-WSAEventSelect

   和WSAAsyncSelect类似,它也允许应用程序在一个或多个套接字上,接收以事件为基础的网络事件通知. 该模型最主要的区别是在于网络事件是由对象句柄完成的,而不是通过窗口例程完成. 事件通知 事件 ...

6. Windows套接字I/O模型（4） -- WSAEventSelect模型

   一.WSAEventSelect模型介绍 WSAEventSelect模型和WSAAsyncSelect模型类似,它也允许应用程序在一个或多个套接字上面,接收以事件为基础的网络事件通知.该模型和WSA ...

7. Windows套接字I/O模型（2） -- Select模型

   一.Select模型介绍 套接字I/O Select模型的"中心思想"便是利用select函数,实现对I/O的管理.利用select函数判断套接字(一个或多个)上是否存在数据,或者 ...

8. 利用套接字实现 CS 模型

   例子:大写转小写. 注意:代码都是运行在Linux内核中. 服务器端: #include <stdio.h> #include <unistd.h> #include < ...

9. 套接字相关数据据结构及分层模型

   主要参考了<深入linux内核架构>和<精通Linux内核网络>相关章节 文章目录 套接字及分层模型 核心基本术语 套接字 网络实现的分层模型 套接字缓冲区及net_devic ...

最新文章

1. 【云栖大会】人工智能：智，在云端
2. 曾经流行的，即将流行的几种渲染模式(render pipeline)
3. 每次执行java命令 都要source_跟着平台混了四年，现在要单飞了！
4. boost::geometry::model::multi_polygon用法的测试程序
5. C#将json字符串解析成对象
6. verilog时钟翻转怎么写_verilog实时可调时钟代码
7. python可以给你干什么-python可以做什么，你心动了吗？
8. 4.携程架构实践 --- 呼叫中心
9. 小米4 第三方re奇兔_小米手机刷机教程整合版
10. 飞思卡尔16位单片机（四）——GPIO输入功能测试
11. 联想g510拆键盘的简单方法_联想G510重点笔记本拆机教程.doc
12. 世界你好python_Python基础01之“你好世界”
13. 远程控制工具哪个好？向日葵VS ToDesk，安卓移动设备远程操控哪个更好用？
14. String字符串中 intern()方法的理解(重难点)
15. Android 产生ANR后的Trace文件的解析
16. 近期尝试UR5和PhantomOmni的联动仿真出现的问题
17. QQ群文件更改默认下载路径方法
18. MACD抓妖神器 通达信指标公式 副图 源码 无加密 无未来
19. flash_acr_latency
20. 前端小游戏（强烈推荐）

热门文章

1. 泰克示波器查眼图_泰克示波器自带上位机软件功能介绍，了解一下
2. mysql 清理 reley_MySQL日志相关
3. js 小数自动补0_JavaScript 时分秒时间代码(自动补零)
4. STM32利用库函数驱动OLED
5. 你的导师是哪种类型？
6. 巫师3狂猎游戏风景Mac动态壁纸
7. P5706 【深基2.例8】再分肥宅水--2022.02.13
8. 第十二届 蓝桥杯 青少年C++组 10月比赛 第1题
9. linux系统可以ping,Linux系统禁ping
10. golang select default continue_golang系列——基础语法