完成端口简介

完成端口原理是:创建一个完成端口与一个SOCKET绑定,所有通过该SOCKET通讯的数据都由完成端口机制来处理,完成端口是异步I/O,接收和发送都是提交后不管结果,所有结果都由完成端口的消息机制来做相应的通知,并且完成端口内部有线程池的概念

 

//www.cnblogs.com/jiayongzhi/archive/2011/05/17/2048286.html

首先来说为什么要使用完成端口：

原因还是因为为了解决recv方法为阻塞式的问题，WinSocket封装的WSARecv方法为非堵塞的方法。

int WSARecv(

SOCKETs,

LPWSABUFlpBuffers,

DWORDdwBufferCount,

LPDWORDlpNumberOfBytesRecvd,

LPDWORDlpFlags,

LPWSAOVERLAPPEDlpOverlapped,

LPWSAOVERLAPPED_COMPLETION_ROUTINElpCompletionRoutine

);

WSARecv为非阻塞的方法，其中第二个参数是I/O请求成功时，数据保存的地址。

Socket的触发是属于网卡硬件的中断信号，只是此信号CPU不能直接获取状态，此时我们可以使之绑定Event事件，Event内核对象的状态时可以监听到的。

这也就是WSAEventSelect模型的原理，当然重叠模型的最终原理也是如此。但Event的方法有着其弊病：当模型处理多线程事件时要调用WSAWaitForMultipleEvents函数，

WSAWaitForMultipleEvents函数一次最多只能等待64个事件对象。所以当海量客户端连接服务器时，服务器将没有能力应对，于是我们使用完成端口。

完成端口：

HANDLE CreateIoCompletionPort(

    HANDLE FileHandle, //要链接的Socket

    HANDLE ExistingCompletionPort, //全局完成端口

//同完成端口关联到一起的句柄，此处可为链接的socket，或是id等等（目地使接收到的socket知道是哪个socket）

    DWORD CompletionKey,

    DWORD NumberOfConcurrentThreads

);

此函数创建创建Socket与完成端口的链接，CreateIoCompletionPort函数被用于完成两个工作：

• 用于创建—个完成端口对象。
• 将一个句柄同完成端口关联到一起。

用函数GetQueuedCompletionStatus等待全局完成端口的完成队列。 

BOOL GetQueuedCompletionStatus(
    
    HANDLE                CompletionPort,

    LPDWORD               lpNumberOfBytes,

    PULONG_PTR        lpCompletionKey,  //此参数为CreateIoCompletionPort第三个参数传过来的句柄,通过此参数获得socket
     
    LPOVERLAPPED*         lpOverlapped,

    DWORD                dwMilliseconds

);   

完成端口的工作原理是，把Socket和完成端口绑定，通过关联句柄传递传递参数，使得获取到的Socket能得知是那个socket，参数可以自定义可以是socket本身也可以是id等等。

1. #include "WinSock2.h"
   
2. 
   
3. #pragma comment(lib,"ws2_32.lib")
   
4. 
   
5. 
   
6. #define MESSAGESIZE 1024
   
7. 
   
8. SOCKET serverSocket;
   
9. 
   
10. DWORD WINAPI SocketProcAccept(LPVOID pParam);
    
11. 
    
12. DWORD WINAPI SocketProcMain(LPVOID pParam);
    
13. 
    
14. enum SOCKETOPERATE
    
15. {
    
16.     soREVC
    
17. };
    
18. 
    
19. struct SOCKETDATA
    
20. {
    
21. 
    
22.     WSAOVERLAPPED overlapped;
    
23. 
    
24.     WSABUF buf;
    
25. 
    
26.     char sMessage[MESSAGESIZE];
    
27. 
    
28.     DWORD dwBytes;
    
29. 
    
30.     DWORD flag;
    
31. 
    
32.     SOCKETOPERATE socketType;
    
33. 
    
34.     void Clear(SOCKETOPERATE type)
    
35.     {
    
36.         ZeroMemory(this, sizeof(SOCKETDATA));
    
37. 
    
38.         buf.buf = sMessage;
    
39. 
    
40.         buf.len= MESSAGESIZE;
    
41. 
    
42.         socketType = type;
    
43.     }
    
44. };
    
45. 
    
46. SOCKET CreateServiceSocket(int Port)
    
47. {
    
48. 
    
49.     int iError;
    
50. 
    
51.     WSAData data;
    
52. 
    
53.     iError = WSAStartup(0x0202,&data);
    
54. 
    
55.     SOCKET tmp = socket(AF_INET,SOCK_STREAM,0);
    
56. 
    
57.     if(tmp== INVALID_SOCKET)
    
58.     {
    
59.         return INVALID_SOCKET;
    
60.     }
    
61. 
    
62.     SOCKADDR_IN addr;
    
63. 
    
64.     addr.sin_addr.s_addr= inet_addr("127.0.0.1");
    
65. 
    
66.     addr.sin_family = AF_INET;
    
67. 
    
68.     addr.sin_port = htons(Port);
    
69. 
    
70.     if((bind(tmp,(sockaddr*)&addr, sizeof(addr)))!= 0)
    
71.     {
    
72.         closesocket(tmp);
    
73. 
    
74.         return INVALID_SOCKET;
    
75.     }
    
76. 
    
77.     if((listen(tmp, INFINITE))!= 0)
    
78.     {
    
79.         closesocket(tmp);
    
80. 
    
81.         return INVALID_SOCKET;
    
82.     }
    
83.     return tmp;
    
84. }
    
85. 
    
86. int _tmain(int argc, _TCHAR* argv[])
    
87. {
    
88.     HANDLE CP = INVALID_HANDLE_VALUE;
    
89. 
    
90.     CP = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL, 0, 0);
    
91. 
    
92.     SYSTEM_INFO systemInfo;
    
93. 
    
94.     GetSystemInfo(&systemInfo);
    
95. 
    
96.     for (int i= 0; i<systemInfo.dwNumberOfProcessors; i++)
    
97.     {
    
98.         CreateThread(NULL,NULL, &SocketProcMain, CP,NULL, NULL);
    
99.     }
    
100. 
     
101.     serverSocket = CreateServiceSocket(6565);
     
102. 
     
103.     if (serverSocket== INVALID_SOCKET)
     
104.     {
     
105.         return 0;
     
106.     }
     
107. 
     
108.     CreateThread(NULL,NULL, &SocketProcAccept, CP,NULL, NULL);
     
109. 
     
110.     while(1)
     
111.     {
     
112.         Sleep(10000);
     
113.     }
     
114. 
     
115.     CloseHandle(CP);
     
116. 
     
117.     closesocket(serverSocket);
     
118. 
     
119.     WSACleanup();
     
120. 
     
121.     return 0;
     
122. }
     
123. 
     
124. DWORD WINAPI SocketProcAccept(LPVOID pParam)
     
125. {
     
126.     HANDLE CP = (HANDLE)pParam;
     
127. 
     
128.     SOCKADDR_IN addr;
     
129. 
     
130.     int len= sizeof(SOCKADDR_IN);
     
131. 
     
132.     SOCKET tmp;
     
133. 
     
134.     SOCKETDATA *lpSocketData;
     
135. 
     
136.     while(1)
     
137.     {
     
138.         tmp = accept(serverSocket,(sockaddr*)&addr,&len);
     
139. 
     
140.         printf("Client Accept:%s\t:%d\n", inet_ntoa(addr.sin_addr), htons(addr.sin_port));
     
141. 
     
142.         CreateIoCompletionPort((HANDLE)tmp, CP,(DWORD)tmp, INFINITE);
     
143. 
     
144.         lpSocketData = (SOCKETDATA *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SOCKETDATA));
     
145. 
     
146.         lpSocketData->Clear(soREVC);
     
147. 
     
148.         WSARecv(tmp,&lpSocketData->buf, 1,&lpSocketData->dwBytes,&lpSocketData->flag,&lpSocketData->overlapped,NULL);
     
149.     }
     
150. }
     
151. 
     
152. DWORD WINAPI SocketProcMain(LPVOID pParam)
     
153. {
     
154.     HANDLE CP = (HANDLE)pParam;
     
155. 
     
156.     SOCKADDR_IN addr;
     
157. 
     
158.     DWORD dwBytes;
     
159. 
     
160.     SOCKETDATA *lpSocketData;
     
161. 
     
162.     SOCKET clientSocket;
     
163.     
     
164.     while(1)
     
165.     {
     
166.         GetQueuedCompletionStatus(CP,&dwBytes, (PULONG_PTR)&clientSocket,(LPOVERLAPPED*)&lpSocketData, INFINITE);
     
167. 
     
168.         if(dwBytes== 0xFFFFFFFF)
     
169.         {
     
170.             return 0;
     
171.         }
     
172. 
     
173.         if(lpSocketData->socketType== soREVC)
     
174.         {
     
175.             if(dwBytes== 0)
     
176.             {
     
177. 
     
178.                 closesocket(clientSocket);
     
179. 
     
180.                 HeapFree(GetProcessHeap(), 0, lpSocketData);
     
181. 
     
182.             }else
     
183.             {
     
184. 
     
185.                 lpSocketData->sMessage[dwBytes]= '\0';
     
186. 
     
187.                 printf("%x\t:%s\n",(DWORD)clientSocket, lpSocketData->sMessage);
     
188. 
     
189.                 lpSocketData->Clear(soREVC);
     
190. 
     
191.                 WSARecv(clientSocket,&lpSocketData->buf, 1,&lpSocketData->dwBytes,&lpSocketData->flag,&lpSocketData->overlapped,NULL);
     
192. 
     
193.             }
     
194. 
     
195.         }
     
196. 
     
197.     }
     
198. }

Socket 重叠I/O 完成端口模型详解

//blog.sina.com.cn/s/blog_3fb7f7270100fesw.html

 

1. 2009年02月23日 星期一 下午 10:07
   
2. #include "stdafx.h"
   
3. 
   
4. #include <WINSOCK2.h>
   
5. #include <stdio.h>
   
6. 
   
7. #define PORT 5150
   
8. #define MSGSIZE 1024
   
9. 
   
10. #pragma comment(lib,"ws2_32.lib")
    
11. 
    
12. typedef enum
    
13. {
    
14.    RECV_POSTED
    
15. }OPERATION_TYPE;//枚举,表示状态
    
16. 
    
17. typedef struct
    
18. {
    
19. WSAOVERLAPPED overlap;
    
20. WSABUF Buffer;
    
21.    char szMessage[MSGSIZE];
    
22. DWORD NumberOfBytesRecvd;
    
23. DWORD Flags;
    
24. OPERATION_TYPE OperationType;
    
25. }PER_IO_OPERATION_DATA,*LPPER_IO_OPERATION_DATA;//定义一个结构体保存IO数据
    
26. 
    
27. DWORD WINAPI WorkerThread(LPVOID);
    
28. 
    
29. int main()
    
30. {
    
31.    WSADATA wsaData;
    
32.    SOCKET sListen, sClient;
    
33.    SOCKADDR_IN local, client;
    
34.    DWORD i, dwThreadId;
    
35.    int iaddrSize = sizeof(SOCKADDR_IN);
    
36.    HANDLE CompletionPort = INVALID_HANDLE_VALUE;
    
37.    SYSTEM_INFO systeminfo;
    
38.    LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
    
39. 
    
40.    // Initialize Windows Socket library
    
41.    WSAStartup(0x0202,&wsaData);
    
42. 
    
43.    // 初始化完成端口
    
44.    CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL, 0, 0);
    
45. 
    
46.    // 有几个CPU就创建几个工作者线程
    
47.    GetSystemInfo(&systeminfo);
    
48.    for (i= 0; i < systeminfo.dwNumberOfProcessors; i++)
    
49.    {
    
50.      CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
    
51.    }
    
52. 
    
53.    // 创建套接字
    
54.    sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    
55. 
    
56.    // 绑定套接字
    
57.    local.sin_addr.S_un.S_addr= htonl(INADDR_ANY);
    
58. local.sin_family = AF_INET;
    
59. local.sin_port = htons(PORT);
    
60.    bind(sListen,(struct sockaddr *)&local, sizeof(SOCKADDR_IN));
    
61. 
    
62.    // 开始监听！
    
63.    listen(sListen, 3);
    
64. 
    
65.    while (TRUE)//主进程的这个循环中循环等待客户端连接，若有连接，则将该客户套接字于完成端口绑定到一起
    
66.       //然后开始异步等待接收客户传来的数据。
    
67.    {
    
68.      // 如果接到客户请求连接，则继续，否则等待。
    
69.      sClient = accept(sListen,(struct sockaddr *)&client,&iaddrSize);
    
70. //client中保存用户信息。
    
71.      printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    
72. 
    
73. //将这个最新到来的客户套接字和完成端口绑定到一起。
    
74.      CreateIoCompletionPort((HANDLE)sClient, CompletionPort,( ULONG_PTR)sClient, 0);
    
75. //第三个参数表示传递的参数，这里就传递的客户套接字地址。最后一个参数为0 表示有和CPU一样的进程数。即1个CPU一个线程
    
76.    
    
77.      // 初始化结构体
    
78.      lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
    
79.        GetProcessHeap(),
    
80.        HEAP_ZERO_MEMORY,
    
81.        sizeof(PER_IO_OPERATION_DATA));
    
82.      lpPerIOData->Buffer.len= MSGSIZE; // len=1024
    
83.      lpPerIOData->Buffer.buf= lpPerIOData->szMessage;
    
84.      lpPerIOData->OperationType= RECV_POSTED;//操作类型
    
85.      WSARecv(sClient,//异步接收消息，立刻返回。
    
86.        &lpPerIOData->Buffer,//获得接收的数据
    
87.        1, //The number of WSABUF structuresin the lpBuffers array.
    
88.        &lpPerIOData->NumberOfBytesRecvd,//接收到的字节数，如果错误返回0
    
89.        &lpPerIOData->Flags,//参数，先不管
    
90.        &lpPerIOData->overlap,//输入这个结构体咯。
    
91.        NULL);
    
92.    }
    
93. 
    
94. 
    
95. //posts an I/O completion packetto an I/O completion port.
    
96.    PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0,NULL);
    
97. CloseHandle(CompletionPort);
    
98. closesocket(sListen);
    
99. WSACleanup();
    
100. return 0;
     
101. }
     
102. //工作者线程有一个参数，是指向完成端口的句柄
     
103. DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
     
104. {
     
105.    HANDLE CompletionPort=(HANDLE)CompletionPortID;
     
106.    DWORD dwBytesTransferred;
     
107.    SOCKET sClient;
     
108.    LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
     
109. 
     
110.    while (TRUE)
     
111.    {
     
112.      GetQueuedCompletionStatus( //遇到可以接收数据则返回，否则等待
     
113.        CompletionPort,
     
114.        &dwBytesTransferred,//返回的字数
     
115.     (PULONG_PTR&)sClient,//是响应的哪个客户套接字？
     
116.        (LPOVERLAPPED *)&lpPerIOData,//得到该套接字保存的IO信息
     
117.        INFINITE);//无限等待咯。不超时的那种。
     
118.      if (dwBytesTransferred== 0xFFFFFFFF)
     
119.      {
     
120.        return 0;
     
121.      }
     
122.    
     
123.      if (lpPerIOData->OperationType== RECV_POSTED)//如果受到数据
     
124.      {
     
125.        if (dwBytesTransferred== 0)
     
126.        {
     
127.          // Connection was closed by client
     
128.          closesocket(sClient);
     
129.          HeapFree(GetProcessHeap(), 0, lpPerIOData);//释放结构体
     
130.        }
     
131.        else
     
132.        {
     
133.          lpPerIOData->szMessage[dwBytesTransferred]= '\0';
     
134.          send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0); //将接收到的消息返回
     
135.        
     
136.          // Launch another asynchronous operationfor sClient
     
137.          memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
     
138.          lpPerIOData->Buffer.len= MSGSIZE;
     
139.          lpPerIOData->Buffer.buf= lpPerIOData->szMessage;
     
140.          lpPerIOData->OperationType= RECV_POSTED;
     
141.          WSARecv(sClient,//循环接收
     
142.     &lpPerIOData->Buffer,
     
143.     1,
     
144.     &lpPerIOData->NumberOfBytesRecvd,
     
145.     &lpPerIOData->Flags,
     
146.     &lpPerIOData->overlap,
     
147.     NULL);
     
148.        }
     
149.      }
     
150.    }
     
151.    return 0;
     
152. }

首先，说说主线程：
1.创建完成端口对象
2.创建工作者线程（这里工作者线程的数量是按照CPU的个数来决定的，这样可以达到最佳性能）
3.创建监听套接字，绑定，监听，然后程序进入循环
4.在循环中，我做了以下几件事情：
(1).接受一个客户端连接
(2).将该客户端套接字与完成端口绑定到一起(还是调用CreateIoCompletionPort，但这次的作用不同)，
注意，按道理来讲，此时传递给CreateIoCompletionPort的第三个参数应该是一个完成键，
一般来讲，程序都是传递一个单句柄数据结构的地址，该单句柄数据包含了和该客户端连接有关的信息，
由于我们只关心套接字句柄，所以直接将套接字句柄作为完成键传递；
(3).触发一个WSARecv异步调用，用到了“尾随数据”，使接收数据所用的缓冲区紧跟在WSAOVERLAPPED对象之后，
此外，还有操作类型等重要信息。

在工作者线程的循环中，我们
1.调用GetQueuedCompletionStatus取得本次I/O的相关信息（例如套接字句柄、传送的字节数、单I/O数据结构的地址等等）
2.通过单I/O数据结构找到接收数据缓冲区，然后将数据原封不动的发送到客户端
3.再次触发一个WSARecv异步操作