IOCP模型與網絡程式設計
一、前言：
1. 我想隻要是寫過或者想要寫C/S模式網絡伺服器端的朋友，都應該或多或少的聽過完成端口的大名吧，完成端口會充分利用Windows核心來進行I/O的排程，是用于C/S通信模式中性能最好的網絡通信模型，沒有之一；甚至連和它性能接近的通信模型都沒有。
2. 完成端口和其他網絡通信方式最大的差別在哪裡呢？
(1) 首先，如果使用“同步”的方式來通信的話，這裡說的同步的方式就是說所有的操作都在一個線程内順序執行完成，這麼做缺點是很明顯的：因為同步的通信操作會阻塞住來自同一個線程的任何其他操作，隻有這個操作完成了之後，後續的操作才可以完成；一個最明顯的例子就是咱們在MFC的界面代碼中，直接使用阻塞Socket調用的代碼，整個界面都會是以而阻塞住沒有響應！是以我們不得不為每一個通信的Socket都要建立一個線程，多麻煩？這不坑爹呢麼？是以要寫高性能的伺服器程式，要求通信一定要是異步的。
(2) 各位讀者肯定知道，可以使用使用“同步通信(阻塞通信)+多線程”的方式來改善(1)的情況，那麼好，想一下，我們好不容易實作了讓伺服器端在每一個用戶端連入之後，都要啟動一個新的Thread和用戶端進行通信，有多少個用戶端，就需要啟動多少個線程，對吧；但是由于這些線程都是處于運作狀态，是以系統不得不在所有可運作的線程之間進行上下文的切換，我們自己是沒啥感覺，但是CPU卻痛苦不堪了，因為線程切換是相當浪費CPU時間的，如果用戶端的連入線程過多，這就會弄得CPU都忙着去切換線程了，根本沒有多少時間去執行線程體了，是以效率是非常低下的，承認坑爹了不？
(3) 而微軟提出完成端口模型的初衷，就是為了解決這種"one-thread-per-client"的缺點的，它充分利用核心對象的排程，隻使用少量的幾個線程來處理和用戶端的所有通信，消除了無謂的線程上下文切換，最大限度的提高了網絡通信的性能，這種神奇的效果具體是如何實作的請看下文。
3. 完成端口被廣泛的應用于各個高性能伺服器程式上，例如著名的Apache….如果你想要編寫的伺服器端需要同時處理的并發用戶端連接配接數量有數百上千個的話，那不用糾結了，就是它了
二、提出相關問題：
1. IOCP模型是什麼？
2. IOCP模型是用來解決什麼問題的？它為什麼存在？
3. 使用IOCP模型需要用到哪些知識？
4. 如何使用IOCP模型與Socket網絡程式設計結合起來？
5. 學會了這個模型以後與我之前寫過的簡單的socket程式主要有哪些不同點？
部分問題探究及解決：
1. 什麼是IOCP？什麼是IOCP模型？IOCP模型有什麼作用？
1) IOCP(I/O Completion Port),常稱I/O完成端口。
2) IOCP模型屬于一種通訊模型，适用于(能控制并發執行的)高負載伺服器的一個技術。
3) 通俗一點說，就是用于高效處理很多很多的用戶端進行資料交換的一個模型。
4) 或者可以說，就是能異步I/O操作的模型。
5) 隻是了解到這些會讓人很糊塗，因為還是不知道它究意具體是個什麼東東呢？
下面我想給大家看三個圖：
第一個是IOCP的内部工作隊列圖。(整合于《IOCP本質論》文章，在英文的基礎上加上中文對照)
第二個是程式實作IOCP模型的基本步驟。(整合于《深入解釋IOCP》，加個人觀點、了解、翻譯)
第三個是使用了IOCP模型及沒使用IOCP模型的程式流程圖。(個人了解繪制)
2. IOCP的存在理由(IOCP的優點)及技術相關有哪些？
之前說過，很通俗地了解可以了解成是用于高效處理很多很多的用戶端進行資料交換的一個模型，那麼，它具體的優點有些什麼呢？它到底用到了哪些技術了呢？在Windows環境下又如何去使用這些技術來程式設計呢？它主要使用上哪些API函數呢？呃~看來我真是一個問題多多的人，跟前面提出的相關問題變種延伸了不少的問題，好吧，下面一個個來解決。
1) 使用IOCP模型程式設計的優點
① 幫助維持重複使用的記憶體池。(與重疊I/O技術有關)
② 去除删除線程建立/終結負擔。
③ 利于管理，配置設定線程，控制并發，最小化的線程上下文切換。
④ 優化線程排程，提高CPU和記憶體緩沖的命中率。
2) 使用IOCP模型程式設計汲及到的知識點(無先後順序)
① 同步與異步
② 阻塞與非阻塞
③ 重疊I/O技術
④ 多線程
⑤ 棧、隊列這兩種基本的資料結構
3) 需要使用上的API函數
① 與SOCKET相關
1、連結套接字動态連結庫：int WSAStartup(...);
2、建立套接字庫： SOCKET socket(...);
3、綁字套接字： int bind(...);
4、套接字設為監聽狀态： int listen(...);
5、接收套接字： SOCKET accept(...);
6、向指定套接字發送資訊：int send(...);
7、從指定套接字接收資訊：int recv(...);
② 與線程相關
1、建立線程：HANDLE CreateThread(...);
③ 重疊I/O技術相關
1、向套接字發送資料： int WSASend(...);
2、向套接字發送資料包： int WSASendFrom(...);
3、從套接字接收資料： int WSARecv(...);
4、從套接字接收資料包： int WSARecvFrom(...);
④ IOCP相關
1、建立完成端口： HANDLE WINAPI CreateIoCompletionPort(...);
2、關聯完成端口： HANDLE WINAPI CreateIoCompletionPort(...);
3、擷取隊列完成狀态: BOOL WINAPI GetQueuedCompletionStatus(...);
4、投遞一個隊列完成狀态：BOOL WINAPI PostQueuedCompletionStatus(...);
四。完整的簡單的IOCP伺服器與用戶端代碼執行個體：
[cpp] view plaincopyprint?
1. // IOCP_TCPIP_Socket_Server.cpp
2.
3. #include
4. #include
5. #include
6. #include
7.
8. using namespace std;
9.
10. #pragma comment(lib, "Ws2_32.lib") // Socket程式設計需用的動态連結庫
11. #pragma comment(lib, "Kernel32.lib") // IOCP需要用到的動态連結庫
12.
13.
17. const int DataBuffSize = 2 * 1024;
18. typedef struct
19. {
20. OVERLAPPED overlapped;
21. WSABUF databuff;
22. char buffer[ DataBuffSize ];
23. int BufferLen;
24. int operationType;
25. }PER_IO_OPERATEION_DATA, *LPPER_IO_OPERATION_DATA, *LPPER_IO_DATA, PER_IO_DATA;
26.
27.
32. typedef struct
33. {
34. SOCKET socket;
35. SOCKADDR_STORAGE ClientAddr;
36. }PER_HANDLE_DATA, *LPPER_HANDLE_DATA;
37.
38. // 定義全局變量
39. const int DefaultPort = 6000;
40. vector < PER_HANDLE_DATA* > clientGroup; // 記錄用戶端的向量組
41.
42. HANDLE hMutex = CreateMutex(NULL, FALSE, NULL);
43. DWORD WINAPI ServerWorkThread(LPVOID CompletionPortID);
44. DWORD WINAPI ServerSendThread(LPVOID IpParam);
45.
46. // 開始主函數
47. int main()
48. {
49. // 加載socket動态連結庫
50. WORD wVersionRequested = MAKEWORD(2, 2); // 請求2.2版本的WinSock庫
51. WSADATA wsaData; // 接收Windows Socket的結構資訊
52. DWORD err = WSAStartup(wVersionRequested, &wsaData);
53.
54. if (0 != err){ // 檢查套接字庫是否申請成功
55. cerr << "Request Windows Socket Library Error!";
56. system("pause");
57. return -1;
58. }
59. if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2){// 檢查是否申請了所需版本的套接字庫
60. WSACleanup();
61. cerr << "Request Windows Socket Version 2.2 Error!";
62. system("pause");
63. return -1;
64. }
65.
66. // 建立IOCP的核心對象
67.
76. HANDLE completionPort = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0);
77. if (NULL == completionPort){ // 建立IO核心對象失敗
78. cerr << "CreateIoCompletionPort failed. Error:" << GetLastError() << endl;
79. system("pause");
80. return -1;
81. }
82.
83. // 建立IOCP線程--線程裡面建立線程池
84.
85. // 确定處理器的核心數量
86. SYSTEM_INFO mySysInfo;
87. GetSystemInfo(&mySysInfo);
88.
89. // 基于處理器的核心數量建立線程
90. for(DWORD i = 0; i < (mySysInfo.dwNumberOfProcessors * 2); ++i){
91. // 建立伺服器工作器線程，并将完成端口傳遞到該線程
92. HANDLE ThreadHandle = CreateThread(NULL, 0, ServerWorkThread, completionPort, 0, NULL);
93. if(NULL == ThreadHandle){
94. cerr << "Create Thread Handle failed. Error:" << GetLastError() << endl;
95. system("pause");
96. return -1;
97. }
98. CloseHandle(ThreadHandle);
99. }
100.
101. // 建立流式套接字
102. SOCKET srvSocket = socket(AF_INET, SOCK_STREAM, 0);
103.
104. // 綁定SOCKET到本機
105. SOCKADDR_IN srvAddr;
106. srvAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
107. srvAddr.sin_family = AF_INET;
108. srvAddr.sin_port = htons(DefaultPort);
109. int bindResult = bind(srvSocket, (SOCKADDR*)&srvAddr, sizeof(SOCKADDR));
110. if(SOCKET_ERROR == bindResult){
111. cerr << "Bind failed. Error:" << GetLastError() << endl;
112. system("pause");
113. return -1;
114. }
115.
116. // 将SOCKET設定為監聽模式
117. int listenResult = listen(srvSocket, 10);
118. if(SOCKET_ERROR == listenResult){
119. cerr << "Listen failed. Error: " << GetLastError() << endl;
120. system("pause");
121. return -1;
122. }
123.
124. // 開始處理IO資料
125. cout << "本伺服器已準備就緒，正在等待用戶端的接入...";
126.
127. // 建立用于發送資料的線程
128. HANDLE sendThread = CreateThread(NULL, 0, ServerSendThread, 0, 0, NULL);
129.
130. while(true){
131. PER_HANDLE_DATA * PerHandleData = NULL;
132. SOCKADDR_IN saRemote;
133. int RemoteLen;
134. SOCKET acceptSocket;
135.
136. // 接收連接配接，并配置設定完成端，這兒可以用AcceptEx()
137. RemoteLen = sizeof(saRemote);
138. acceptSocket = accept(srvSocket, (SOCKADDR*)&saRemote, &RemoteLen);
139. if(SOCKET_ERROR == acceptSocket){ // 接收用戶端失敗
140. cerr << "Accept Socket Error: " << GetLastError() << endl;
141. system("pause");
142. return -1;
143. }
144.
145. // 建立用來和套接字關聯的單句柄資料資訊結構
146. PerHandleData = (LPPER_HANDLE_DATA)GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA)); // 在堆中為這個PerHandleData申請指定大小的記憶體
147. PerHandleData -> socket = acceptSocket;
148. memcpy (&PerHandleData -> ClientAddr, &saRemote, RemoteLen);
149. clientGroup.push_back(PerHandleData); // 将單個用戶端資料指針放到用戶端組中
150.
151. // 将接受套接字和完成端口關聯
152. CreateIoCompletionPort((HANDLE)(PerHandleData -> socket), completionPort, (DWORD)PerHandleData, 0);
153.
154.
155. // 開始在接受套接字上處理I/O使用重疊I/O機制
156. // 在建立的套接字上投遞一個或多個異步
157. // WSARecv或WSASend請求，這些I/O請求完成後，工作者線程會為I/O請求提供服務
158. // 單I/O操作資料(I/O重疊)
159. LPPER_IO_OPERATION_DATA PerIoData = NULL;
160. PerIoData = (LPPER_IO_OPERATION_DATA)GlobalAlloc(GPTR, sizeof(PER_IO_OPERATEION_DATA));
161. ZeroMemory(&(PerIoData -> overlapped), sizeof(OVERLAPPED));
162. PerIoData->databuff.len = 1024;
163. PerIoData->databuff.buf = PerIoData->buffer;
164. PerIoData->operationType = 0; // read
165.
166. DWORD RecvBytes;
167. DWORD Flags = 0;
168. WSARecv(PerHandleData->socket, &(PerIoData->databuff), 1, &RecvBytes, &Flags, &(PerIoData->overlapped), NULL);
169. }
170.
171. system("pause");
172. return 0;
173. }
174.
175. // 開始服務工作線程函數
176. DWORD WINAPI ServerWorkThread(LPVOID IpParam)
177. {
178. HANDLE CompletionPort = (HANDLE)IpParam;
179. DWORD BytesTransferred;
180. LPOVERLAPPED IpOverlapped;
181. LPPER_HANDLE_DATA PerHandleData = NULL;
182. LPPER_IO_DATA PerIoData = NULL;
183. DWORD RecvBytes;
184. DWORD Flags = 0;
185. BOOL bRet = false;
186.
187. while(true){
188. bRet = GetQueuedCompletionStatus(CompletionPort, &BytesTransferred, (PULONG_PTR)&PerHandleData, (LPOVERLAPPED*)&IpOverlapped, INFINITE);
189. if(bRet == 0){
190. cerr << "GetQueuedCompletionStatus Error: " << GetLastError() << endl;
191. return -1;
192. }
193. PerIoData = (LPPER_IO_DATA)CONTAINING_RECORD(IpOverlapped, PER_IO_DATA, overlapped);
194.
195. // 檢查在套接字上是否有錯誤發生
196. if(0 == BytesTransferred){
197. closesocket(PerHandleData->socket);
198. GlobalFree(PerHandleData);
199. GlobalFree(PerIoData);
200. continue;
201. }
202.
203. // 開始資料處理，接收來自用戶端的資料
204. WaitForSingleObject(hMutex,INFINITE);
205. cout << "A Client says: " << PerIoData->databuff.buf << endl;
206. ReleaseMutex(hMutex);
207.
208. // 為下一個重疊調用建立單I/O操作資料
209. ZeroMemory(&(PerIoData->overlapped), sizeof(OVERLAPPED)); // 清空記憶體
210. PerIoData->databuff.len = 1024;
211. PerIoData->databuff.buf = PerIoData->buffer;
212. PerIoData->operationType = 0; // read
213. WSARecv(PerHandleData->socket, &(PerIoData->databuff), 1, &RecvBytes, &Flags, &(PerIoData->overlapped), NULL);
214. }
215.
216. return 0;
217. }
218.
219.
220. // 發送資訊的線程執行函數
221. DWORD WINAPI ServerSendThread(LPVOID IpParam)
222. {
223. while(1){
224. char talk[200];
225. gets(talk);
226. int len;
227. for (len = 0; talk[len] != '0'; ++len){
228. // 找出這個字元組的長度
229. }
230. talk[len] = '';
231. talk[++len] = '0';
232. printf("I Say:");
233. cout << talk;
234. WaitForSingleObject(hMutex,INFINITE);
235. for(int i = 0; i < clientGroup.size(); ++i){
236. send(clientGroup[i]->socket, talk, 200, 0); // 發送資訊
237. }
238. ReleaseMutex(hMutex);
239. }
240. return 0;
241. }
[cpp] view plaincopyprint?
1. // IOCP_TCPIP_Socket_Client.cpp
2.
3. #include
4. #include
5. #include
6. #include
10. using namespace std;
11.
12. #pragma comment(lib, "Ws2_32.lib") // Socket程式設計需用的動态連結庫
13.
14. SOCKET sockClient; // 連接配接成功後的套接字
15. HANDLE bufferMutex; // 令其能互斥成功正常通信的信号量句柄
16. const int DefaultPort = 6000;
17.
18. int main()
19. {
20. // 加載socket動态連結庫(dll)
21. WORD wVersionRequested;
22. WSADATA wsaData; // 這結構是用于接收Wjndows Socket的結構資訊的
23. wVersionRequested = MAKEWORD( 2, 2 ); // 請求2.2版本的WinSock庫
24. int err = WSAStartup( wVersionRequested, &wsaData );
25. if ( err != 0 ) { // 傳回值為零的時候是表示成功申請WSAStartup
26. return -1;
27. }
28. if ( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 2 ) { // 檢查版本号是否正确
29. WSACleanup( );
30. return -1;
31. }
32.
33. // 建立socket操作，建立流式套接字，傳回套接字号sockClient
34. sockClient = socket(AF_INET, SOCK_STREAM, 0);
35. if(sockClient == INVALID_SOCKET) {
36. printf("Error at socket():%ld", WSAGetLastError());
37. WSACleanup();
38. return -1;
39. }
40.
41. // 将套接字sockClient與遠端主機相連
42. // int connect( SOCKET s, const struct sockaddr* name, int namelen);
43. // 第一個參數：需要進行連接配接操作的套接字
44. // 第二個參數：設定所需要連接配接的位址資訊
45. // 第三個參數：位址的長度
46. SOCKADDR_IN addrSrv;
47. addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); // 本地回路位址是127.0.0.1;
48. addrSrv.sin_family = AF_INET;
49. addrSrv.sin_port = htons(DefaultPort);
50. while(SOCKET_ERROR == connect(sockClient, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR))){
51. // 如果還沒連接配接上伺服器則要求重連
52. cout << "伺服器連接配接失敗，是否重新連接配接？(Y/N):";
53. char choice;
54. while(cin >> choice && (!((choice != 'Y' && choice == 'N') || (choice == 'Y' && choice != 'N')))){
55. cout << "輸入錯誤，請重新輸入:";
56. cin.sync();
57. cin.clear();
58. }
59. if (choice == 'Y'){
60. continue;
61. }
62. else{
63. cout << "退出系統中...";
64. system("pause");
65. return 0;
66. }
67. }
68. cin.sync();
69. cout << "本用戶端已準備就緒，使用者可直接輸入文字向伺服器回報資訊。";
70.
71. send(sockClient, "Attention: A Client has enter...", 200, 0);
72.
73. bufferMutex = CreateSemaphore(NULL, 1, 1, NULL);
74.
75. DWORD WINAPI SendMessageThread(LPVOID IpParameter);
76. DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter);
77.
78. HANDLE sendThread = CreateThread(NULL, 0, SendMessageThread, NULL, 0, NULL);
79. HANDLE receiveThread = CreateThread(NULL, 0, ReceiveMessageThread, NULL, 0, NULL);
80.
81.
82. WaitForSingleObject(sendThread, INFINITE); // 等待線程結束
83. closesocket(sockClient);
84. CloseHandle(sendThread);
85. CloseHandle(receiveThread);
86. CloseHandle(bufferMutex);
87. WSACleanup(); // 終止對套接字庫的使用
88.
89. printf("End linking...");
90. printf("");
91. system("pause");
92. return 0;
93. }
94.
95.
96. DWORD WINAPI SendMessageThread(LPVOID IpParameter)
97. {
98. while(1){
99. string talk;
100. getline(cin, talk);
101. WaitForSingleObject(bufferMutex, INFINITE); // P(資源未被占用)
102. if("quit" == talk){
103. talk.push_back('0');
104. send(sockClient, talk.c_str(), 200, 0);
105. break;
106. }
107. else{
108. talk.append("");
109. }
110. printf("I Say:("quit"to exit):");
111. cout << talk;
112. send(sockClient, talk.c_str(), 200, 0); // 發送資訊
113. ReleaseSemaphore(bufferMutex, 1, NULL); // V(資源占用完畢)
114. }
115. return 0;
116. }
117.
118.
119. DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter)
120. {
121. while(1){
122. char recvBuf[300];
123. recv(sockClient, recvBuf, 200, 0);
124. WaitForSingleObject(bufferMutex, INFINITE); // P(資源未被占用)
125.
126. printf("%s Says: %s", "Server", recvBuf); // 接收資訊
127.
128. ReleaseSemaphore(bufferMutex, 1, NULL); // V(資源占用完畢)
129. }
130. return 0;
131. }