當前位置：首頁 > 运维知识 > windows >内容正文

windows

Windows Socket五种I/O模型

發布時間：2025/3/17 windows 13 豆豆

生活随笔收集整理的這篇文章主要介紹了 Windows Socket五种I/O模型小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

? ? ?如果你想在Windows平臺上構建服務器應用，那么I/O模型是你必須考慮的。Windows操作系統提供了Select、WSAAsyncSelect、WSAEventSelect、Overlapped I/O和Completion Port共五種I/O模型。每一種模型均適用于一種特定的應用場景。寫代碼時應該對自己的應用需求非常明確，而且綜合考慮到程序的擴展性和可移植性等因素，作出自己的選擇。

? ? ? ? 客戶端的代碼（為代碼直觀，省去所有錯誤檢查，以下同）:

#include?<WINSOCK2.H> #include?<stdio.h> #define?SERVER_ADDRESS?"137.117.2.148" #define?PORT???????????5150 #define?MSGSIZE????????1024 #pragma?comment(lib,?"ws2_32.lib") int?main() {WSADATA?????wsaData;SOCKET??????sClient;SOCKADDR_IN?server;char????????szMessage[MSGSIZE];int?????????ret;?WSAStartup(0x0202,?&wsaData);?sClient?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);?memset(&server,?0,?sizeof(SOCKADDR_IN));server.sin_family?=?AF_INET;server.sin_addr.S_un.S_addr?=?inet_addr(SERVER_ADDRESS);server.sin_port?=?htons(PORT);connect(sClient,?(struct?sockaddr?*)&server,?sizeof(SOCKADDR_IN));while?(TRUE){printf("Send:");gets(szMessage);?send(sClient,?szMessage,?strlen(szMessage),?0);//?Receive?messageret?=?recv(sClient,?szMessage,?MSGSIZE,?0);szMessage[ret]?=?'\0';printf("Received?[%d?bytes]:?'%s'\n",?ret,?szMessage);}//?Clean?upclosesocket(sClient);WSACleanup();return?0; }

????客戶端所做的事情相當簡單，創建套接字，連接服務器，然后不停的發送和接收數據。

? ??比較容易想到的一種服務器模型就是采用一個主線程，負責監聽客戶端的連接請求，當接收到某個客戶端的連接請求后，創建一個專門用于和該客戶端通信的套接字和一個輔助線程。以后該客戶端和服務器的交互都在這個輔助線程內完成。這種方法比較直觀，程序非常簡單而且可移植性好，但是不能利用平臺相關的特性。例如，如果連接數增多的時候（成千上萬的連接），那么線程數成倍增長，操作系統忙于頻繁的線程間切換，而且大部分線程在其生命周期內都是處于非活動狀態的，這大大浪費了系統的資源。

一.選擇模型
??? ????Select模型是Winsock中最常見的I/O模型。之所以稱其為“Select模型”，是由于它的“中心思想”便是利用select函數，實現對I/O的管理。最初設計該模型時，主要面向的是某些使用UNIX操作系統的計算機，它們采用的是Berkeley套接字方案。Select模型已集成到Winsock 1.1中，它使那些想避免在套接字調用過程中被無辜“鎖定”的應用程序，采取一種有序的方式，同時進行對多個套接字的管理。
服務器的代碼（已經不能再精簡了）：

#include?<winsock.h> #include?<stdio.h> #define?PORT???????5150 #define?MSGSIZE????1024 #pragma?comment(lib,?"ws2_32.lib") int????g_iTotalConn?=?0; SOCKET?g_CliSocketArr[FD_SETSIZE]; DWORD?WINAPI?WorkerThread(LPVOID?lpParameter); int?main() {WSADATA?????wsaData;SOCKET??????sListen,?sClient;SOCKADDR_IN?local,?client;int?????????iaddrSize?=?sizeof(SOCKADDR_IN);DWORD???????dwThreadId;WSAStartup(0x0202,?&wsaData);sListen?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);local.sin_addr.S_un.S_addr?=?htonl(INADDR_ANY);local.sin_family?=?AF_INET;local.sin_port?=?htons(PORT);bind(sListen,?(struct?sockaddr?*)&local,?sizeof(SOCKADDR_IN));listen(sListen,?3);CreateThread(NULL,?0,?WorkerThread,?NULL,?0,?&dwThreadId);??while?(TRUE){sClient?=?accept(sListen,?(struct?sockaddr?*)&client,?&iaddrSize);printf("Accepted?client:%s:%d\n",?inet_ntoa(client.sin_addr),?ntohs(client.sin_port));g_CliSocketArr[g_iTotalConn++]?=?sClient;}return?0; } DWORD?WINAPI?WorkerThread(LPVOID?lpParam) {int????????????i;fd_set?????????fdread;int????????????ret;struct?timeval?tv?=?{1,?0};char???????????szMessage[MSGSIZE];while?(TRUE){FD_ZERO(&fdread);for?(i?=?0;?i?<?g_iTotalConn;?i++){FD_SET(g_CliSocketArr[i],?&fdread);}ret?=?select(0,?&fdread,?NULL,?NULL,?&tv);if?(ret?==?0){continue;}for?(i?=?0;?i?<?g_iTotalConn;?i++){if?(FD_ISSET(g_CliSocketArr[i],?&fdread)){ret?=?recv(g_CliSocketArr[i],?szMessage,?MSGSIZE,?0);if?(ret?==?0?||?(ret?==?SOCKET_ERROR?&&?WSAGetLastError()?==?WSAECONNRESET)){printf("Client?socket?%d?closed.\n",?g_CliSocketArr[i]);closesocket(g_CliSocketArr[i]);if?(i?<?g_iTotalConn?-?1){????????????g_CliSocketArr[i--]?=?g_CliSocketArr[--g_iTotalConn];}}else{szMessage[ret]?=?'\0';send(g_CliSocketArr[i],?szMessage,?strlen(szMessage),?0);}}}}return?0; }

?服務器的幾個主要動作如下：
??? ????1.創建監聽套接字，綁定，監聽；
??? ????2.創建工作者線程；
??? ????3.創建一個套接字數組，用來存放當前所有活動的客戶端套接字，每accept一個連接就更新一次數組；
??? ????4.接受客戶端的連接。這里有一點需要注意的，就是我沒有重新定義FD_SETSIZE宏，所以服務器最多支持的并發連接數為64。而且，這里決不能無條件的accept,服務器應該根據當前的連接數來決定是否接受來自某個客戶端的連接。一種比較好的實現方案就是采用WSAAccept函數，而且讓WSAAccept回調自己實現的Condition Function。

工作者線程里面是一個死循環，一次循環完成的動作是：
??? ????1.將當前所有的客戶端套接字加入到讀集fdread中；
??? ????2.調用select函數；
??? ????3.查看某個套接字是否仍然處于

讀集中，如果是，則接收數據。如果接收的數據長度為0，或者發生WSAECONNRESET錯誤，則表示客戶端套接字主動關閉，這時需要將服務器中對應的套接字所綁定的資源釋放掉，然后調整我們的套接字數組（將數組中最后一個套接字挪到當前的位置上）

???????除了需要有條件接受客戶端的連接外，還需要在連接數為0的情形下做特殊處理，因為如果讀集中沒有任何套接字，select函數會立刻返回，這將導致工作者線程成為一個毫無停頓的死循環，CPU的占用率馬上達到100%。

?二.異步選擇
??? ????Winsock提供了一個有用的異步I/O模型。利用這個模型，應用程序可在一個套接字上，接收以Windows消息為基礎的網絡事件通知。具體的做法是在建好一個套接字后，調用WSAAsyncSelect函數。在它們用一個標準的Windows例程，對窗口消息進行管理的時候使用比較好。

#include?<winsock.h> #include?<tchar.h> #define?PORT??????5150 #define?MSGSIZE???1024 #define?WM_SOCKET?WM_USER+0 #pragma?comment(lib,?"ws2_32.lib") LRESULT?CALLBACK?WndProc(HWND,?UINT,?WPARAM,?LPARAM); int?WINAPI?WinMain(HINSTANCE?hInstance,?HINSTANCE?hPrevInstance,?PSTR?szCmdLine,?int?iCmdShow) {static?TCHAR?szAppName[]?=?_T("AsyncSelect?Model");HWND?????????hwnd?;MSG??????????msg?;WNDCLASS?????wndclass?;wndclass.style?????????=?CS_HREDRAW?|?CS_VREDRAW?;wndclass.lpfnWndProc???=?WndProc?;wndclass.cbClsExtra????=?0?;wndclass.cbWndExtra????=?0?;wndclass.hInstance?????=?hInstance?;wndclass.hIcon?????????=?LoadIcon?(NULL,?IDI_APPLICATION)?;wndclass.hCursor???????=?LoadCursor?(NULL,?IDC_ARROW)?;wndclass.hbrBackground?=?(HBRUSH)?GetStockObject?(WHITE_BRUSH)?;wndclass.lpszMenuName??=?NULL?;wndclass.lpszClassName?=?szAppName?;if?(!RegisterClass(&wndclass)){MessageBox?(NULL,?TEXT?("This?program?requires?Windows?NT!"),?szAppName,?MB_ICONERROR)?;return?0?;}hwnd?=?CreateWindow?(szAppName,??????????????????//?window?class?nameTEXT?("AsyncSelect?Model"),?//?window?captionWS_OVERLAPPEDWINDOW,????????//?window?styleCW_USEDEFAULT,??????????????//?initial?x?positionCW_USEDEFAULT,??????????????//?initial?y?positionCW_USEDEFAULT,??????????????//?initial?x?sizeCW_USEDEFAULT,??????????????//?initial?y?sizeNULL,???????????????????????//?parent?window?handleNULL,???????????????????????//?window?menu?handlehInstance,??????????????????//?program?instance?handleNULL)?;?????????????????????//?creation?parametersShowWindow(hwnd,?iCmdShow);UpdateWindow(hwnd);while?(GetMessage(&msg,?NULL,?0,?0)){TranslateMessage(&msg)?;DispatchMessage(&msg)?;}return?msg.wParam; } LRESULT?CALLBACK?WndProc?(HWND?hwnd,?UINT?message,?WPARAM?wParam,?LPARAM?lParam) {WSADATA???????wsd;static?SOCKET?sListen;SOCKET????????sClient;SOCKADDR_IN???local,?client;int???????????ret,?iAddrSize?=?sizeof(client);char??????????szMessage[MSGSIZE];switch?(message){case?WM_CREATE://?Initialize?Windows?Socket?libraryWSAStartup(0x0202,?&wsd);//?Create?listening?socketsListen?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);//?Bindlocal.sin_addr.S_un.S_addr?=?htonl(INADDR_ANY);local.sin_family?=?AF_INET;local.sin_port?=?htons(PORT);bind(sListen,?(struct?sockaddr?*)&local,?sizeof(local));//?Listenlisten(sListen,?3);//?Associate?listening?socket?with?FD_ACCEPT?eventWSAAsyncSelect(sListen,?hwnd,?WM_SOCKET,?FD_ACCEPT);return?0;case?WM_DESTROY:closesocket(sListen);WSACleanup();PostQuitMessage(0);return?0;case?WM_SOCKET:if?(WSAGETSELECTERROR(lParam)){closesocket(wParam);break;}switch?(WSAGETSELECTEVENT(lParam)){case?FD_ACCEPT://?Accept?a?connection?from?clientsClient?=?accept(wParam,?(struct?sockaddr?*)&client,?&iAddrSize);//?Associate?client?socket?with?FD_READ?and?FD_CLOSE?eventWSAAsyncSelect(sClient,?hwnd,?WM_SOCKET,?FD_READ?|?FD_CLOSE);break;case?FD_READ:ret?=?recv(wParam,?szMessage,?MSGSIZE,?0);if?(ret?==?0?||?ret?==?SOCKET_ERROR?&&?WSAGetLastError()?==?WSAECONNRESET){closesocket(wParam);}else{szMessage[ret]?=?'\0';send(wParam,?szMessage,?strlen(szMessage),?0);}break;case?FD_CLOSE:closesocket(wParam);??????break;}return?0;}return?DefWindowProc(hwnd,?message,?wParam,?lParam); }

在我看來，WSAAsyncSelect是最簡單的一種Winsock I/O模型（因為一個主線程就搞定了）。使用RawWindows API寫過窗口類應用程序的人應該都能看得懂。這里，我們需要做的僅僅是：
??? ????1.在WM_CREATE消息處理函數中，初始化Windows Socket library，創建監聽套接字，綁定，監聽，并且調用WSAAsyncSelect函數表示我們關心在監聽套接字上發生的FD_ACCEPT事件；
??? ????2.自定義一個消息WM_SOCKET，一旦在我們所關心的套接字（監聽套接字和客戶端套接字）上發生了某個事件，系統就會調用WndProc并且message參數被設置為WM_SOCKET；
??? ????3.在WM_SOCKET的消息處理函數中，分別對FD_ACCEPT、FD_READ和FD_CLOSE事件進行處理；
??? ????4.在窗口銷毀消息(WM_DESTROY)的處理函數中，我們關閉監聽套接字，清除Windows Socket library。

三.事件選擇
??? ????Winsock提供了另一個有用的異步I/O模型。和WSAAsyncSelect模型類似的是，它也允許應用程序在一個或多個套接字上，接收以事件為基礎的網絡事件通知。由WSAAsyncSelect模型采用的網絡事件來說，它們均可原封不動地移植到新模型。在用新模型開發的應用程序中，也能接收和處理所有那些事件。該模型最主要的差別在于網絡事件會投遞至一個事件對象句柄，而非投遞至一個窗口例程。

#include?<winsock2.h> #include?<stdio.h> #define?PORT????5150 #define?MSGSIZE?1024 #pragma?comment(lib,?"ws2_32.lib") int??????g_iTotalConn?=?0; SOCKET???g_CliSocketArr[MAXIMUM_WAIT_OBJECTS]; WSAEVENT?g_CliEventArr[MAXIMUM_WAIT_OBJECTS]; DWORD?WINAPI?WorkerThread(LPVOID); void?Cleanup(int?index); int?main() {WSADATA?????wsaData;SOCKET??????sListen,?sClient;SOCKADDR_IN?local,?client;DWORD???????dwThreadId;int?????????iaddrSize?=?sizeof(SOCKADDR_IN);//?Initialize?Windows?Socket?libraryWSAStartup(0x0202,?&wsaData);//?Create?listening?socketsListen?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);//?Bindlocal.sin_addr.S_un.S_addr?=?htonl(INADDR_ANY);local.sin_family?=?AF_INET;local.sin_port?=?htons(PORT);bind(sListen,?(struct?sockaddr?*)&local,?sizeof(SOCKADDR_IN));//?Listenlisten(sListen,?3);//?Create?worker?threadCreateThread(NULL,?0,?WorkerThread,?NULL,?0,?&dwThreadId);while?(TRUE){//?Accept?a?connectionsClient?=?accept(sListen,?(struct?sockaddr?*)&client,?&iaddrSize);printf("Accepted?client:%s:%d\n",?inet_ntoa(client.sin_addr),?ntohs(client.sin_port));//?Associate?socket?with?network?eventg_CliSocketArr[g_iTotalConn]?=?sClient;g_CliEventArr[g_iTotalConn]?=?WSACreateEvent();WSAEventSelect(g_CliSocketArr[g_iTotalConn],?g_CliEventArr[g_iTotalConn],?FD_READ?|?FD_CLOSE);g_iTotalConn++;} } DWORD?WINAPI?WorkerThread(LPVOID?lpParam) {int??????????????ret,?index;WSANETWORKEVENTS?NetworkEvents;char?????????????szMessage[MSGSIZE];while?(TRUE){ret?=?WSAWaitForMultipleEvents(g_iTotalConn,?g_CliEventArr,?FALSE,?1000,?FALSE);if?(ret?==?WSA_WAIT_FAILED?||?ret?==?WSA_WAIT_TIMEOUT){continue;}index?=?ret?-?WSA_WAIT_EVENT_0;WSAEnumNetworkEvents(g_CliSocketArr[index],?g_CliEventArr[index],?&NetworkEvents);if?(NetworkEvents.lNetworkEvents?&?FD_READ){//?Receive?message?from?clientret?=?recv(g_CliSocketArr[index],?szMessage,?MSGSIZE,?0);if?(ret?==?0?||?(ret?==?SOCKET_ERROR?&&?WSAGetLastError()?==?WSAECONNRESET)){Cleanup(index);}else{szMessage[ret]?=?'\0';send(g_CliSocketArr[index],?szMessage,?strlen(szMessage),?0);}}if?(NetworkEvents.lNetworkEvents?&?FD_CLOSE){Cleanup(index);}}return?0; } void?Cleanup(int?index) {closesocket(g_CliSocketArr[index]);WSACloseEvent(g_CliEventArr[index]);if?(index?<?g_iTotalConn?-?1){g_CliSocketArr[index]?=?g_CliSocketArr[g_iTotalConn?-?1];g_CliEventArr[index]?=?g_CliEventArr[g_iTotalConn?-?1];}g_iTotalConn--; }

事件選擇模型也比較簡單，實現起來也不是太復雜，它的基本思想是將每個套接字都和一個WSAEVENT對象對應起來，并且在關聯的時候指定需要關注的哪些網絡事件。一旦在某個套接字上發生了我們關注的事件（FD_READ和FD_CLOSE），與之相關聯的WSAEVENT對象被Signaled。程序定義了兩個全局數組，一個套接字數組，一個WSAEVENT對象數組，其大小都是MAXIMUM_WAIT_OBJECTS（64），兩個數組中的元素一一對應。
??? ????同樣的，這里的程序沒有考慮兩個問題，一是不能無條件的調用accept，因為我們支持的并發連接數有限。解決方法是將套接字按MAXIMUM_WAIT_OBJECTS分組，每MAXIMUM_WAIT_OBJECTS個套接字一組，每一組分配一個工作者線程；或者采用WSAAccept代替accept，并回調自己定義的Condition Function。第二個問題是沒有對連接數為0的情形做特殊處理，程序在連接數為0的時候CPU占用率為100%。

四.重疊I/O模型
??? ????Winsock2的發布使得Socket I/O有了和文件I/O統一的接口。我們可以通過使用Win32文件操縱函數ReadFile和WriteFile來進行Socket I/O。伴隨而來的，用于普通文件I/O的重疊I/O模型和完成端口模型對Socket I/O也適用了。這些模型的優點是可以達到更佳的系統性能，但是實現較為復雜，里面涉及較多的C語言技巧。例如我們在完成端口模型中會經常用到所謂的“尾隨數據”。

?1.用事件通知方式實現的重疊I/O模型

#include?<winsock2.h> #include?<stdio.h> #define?PORT????5150 #define?MSGSIZE?1024 #pragma?comment(lib,?"ws2_32.lib") typedef?struct {WSAOVERLAPPED?overlap;WSABUF????????Buffer;char??????????szMessage[MSGSIZE];DWORD?????????NumberOfBytesRecvd;DWORD?????????Flags; }PER_IO_OPERATION_DATA,?*LPPER_IO_OPERATION_DATA; int?????????????????????g_iTotalConn?=?0; SOCKET??????????????????g_CliSocketArr[MAXIMUM_WAIT_OBJECTS]; WSAEVENT????????????????g_CliEventArr[MAXIMUM_WAIT_OBJECTS]; LPPER_IO_OPERATION_DATA?g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS]; DWORD?WINAPI?WorkerThread(LPVOID); void?Cleanup(int); int?main() {WSADATA?????wsaData;SOCKET??????sListen,?sClient;SOCKADDR_IN?local,?client;DWORD???????dwThreadId;int?????????iaddrSize?=?sizeof(SOCKADDR_IN);//?Initialize?Windows?Socket?libraryWSAStartup(0x0202,?&wsaData);//?Create?listening?socketsListen?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);//?Bindlocal.sin_addr.S_un.S_addr?=?htonl(INADDR_ANY);local.sin_family?=?AF_INET;local.sin_port?=?htons(PORT);bind(sListen,?(struct?sockaddr?*)&local,?sizeof(SOCKADDR_IN));//?Listenlisten(sListen,?3);//?Create?worker?threadCreateThread(NULL,?0,?WorkerThread,?NULL,?0,?&dwThreadId);while?(TRUE){//?Accept?a?connectionsClient?=?accept(sListen,?(struct?sockaddr?*)&client,?&iaddrSize);printf("Accepted?client:%s:%d\n",?inet_ntoa(client.sin_addr),?ntohs(client.sin_port));g_CliSocketArr[g_iTotalConn]?=?sClient;//?Allocate?a?PER_IO_OPERATION_DATA?structureg_pPerIODataArr[g_iTotalConn]?=?(LPPER_IO_OPERATION_DATA)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PER_IO_OPERATION_DATA));g_pPerIODataArr[g_iTotalConn]->Buffer.len?=?MSGSIZE;g_pPerIODataArr[g_iTotalConn]->Buffer.buf?=?g_pPerIODataArr[g_iTotalConn]->szMessage;g_CliEventArr[g_iTotalConn]?=?g_pPerIODataArr[g_iTotalConn]->overlap.hEvent?=?WSACreateEvent();//?Launch?an?asynchronous?operationWSARecv(g_CliSocketArr[g_iTotalConn],&g_pPerIODataArr[g_iTotalConn]->Buffer,1,&g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd,&g_pPerIODataArr[g_iTotalConn]->Flags,&g_pPerIODataArr[g_iTotalConn]->overlap,NULL);g_iTotalConn++;}closesocket(sListen);WSACleanup();return?0; } DWORD?WINAPI?WorkerThread(LPVOID?lpParam) {int???ret,?index;DWORD?cbTransferred;while?(TRUE){ret?=?WSAWaitForMultipleEvents(g_iTotalConn,?g_CliEventArr,?FALSE,?1000,?FALSE);if?(ret?==?WSA_WAIT_FAILED?||?ret?==?WSA_WAIT_TIMEOUT){continue;}index?=?ret?-?WSA_WAIT_EVENT_0;WSAResetEvent(g_CliEventArr[index]);WSAGetOverlappedResult(g_CliSocketArr[index],&g_pPerIODataArr[index]->overlap,&cbTransferred,TRUE,&g_pPerIODataArr[g_iTotalConn]->Flags);if?(cbTransferred?==?0){//?The?connection?was?closed?by?clientCleanup(index);}else{//?g_pPerIODataArr[index]->szMessage?contains?the?received?datag_pPerIODataArr[index]->szMessage[cbTransferred]?=?'\0';send(g_CliSocketArr[index],?g_pPerIODataArr[index]->szMessage,\cbTransferred,?0);//?Launch?another?asynchronous?operationWSARecv(g_CliSocketArr[index],&g_pPerIODataArr[index]->Buffer,1,&g_pPerIODataArr[index]->NumberOfBytesRecvd,&g_pPerIODataArr[index]->Flags,&g_pPerIODataArr[index]->overlap,NULL);}}return?0; } void?Cleanup(int?index) {closesocket(g_CliSocketArr[index]);WSACloseEvent(g_CliEventArr[index]);HeapFree(GetProcessHeap(),?0,?g_pPerIODataArr[index]);if?(index?<?g_iTotalConn?-?1){g_CliSocketArr[index]?=?g_CliSocketArr[g_iTotalConn?-?1];g_CliEventArr[index]?=?g_CliEventArr[g_iTotalConn?-?1];g_pPerIODataArr[index]?=?g_pPerIODataArr[g_iTotalConn?-?1];}g_pPerIODataArr[--g_iTotalConn]?=?NULL; }

這個模型與上述其他模型不同的是它使用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異步操作。

2.用完成例程方式實現的重疊I/O模型

#include?<WINSOCK2.H> #include?<stdio.h> #define?PORT????5150 #define?MSGSIZE?1024 #pragma?comment(lib,?"ws2_32.lib") typedef?struct {WSAOVERLAPPED?overlap;WSABUF????????Buffer;char??????????szMessage[MSGSIZE];DWORD?????????NumberOfBytesRecvd;DWORD?????????Flags;?SOCKET????????sClient; }PER_IO_OPERATION_DATA,?*LPPER_IO_OPERATION_DATA; DWORD?WINAPI?WorkerThread(LPVOID); void?CALLBACK?CompletionROUTINE(DWORD,?DWORD,?LPWSAOVERLAPPED,?DWORD); SOCKET?g_sNewClientConnection; BOOL???g_bNewConnectionArrived?=?FALSE; int?main() {WSADATA?????wsaData;SOCKET??????sListen;SOCKADDR_IN?local,?client;DWORD???????dwThreadId;int?????????iaddrSize?=?sizeof(SOCKADDR_IN);//?Initialize?Windows?Socket?libraryWSAStartup(0x0202,?&wsaData);//?Create?listening?socketsListen?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);//?Bindlocal.sin_addr.S_un.S_addr?=?htonl(INADDR_ANY);local.sin_family?=?AF_INET;local.sin_port?=?htons(PORT);bind(sListen,?(struct?sockaddr?*)&local,?sizeof(SOCKADDR_IN));//?Listenlisten(sListen,?3);//?Create?worker?threadCreateThread(NULL,?0,?WorkerThread,?NULL,?0,?&dwThreadId);while?(TRUE){//?Accept?a?connectiong_sNewClientConnection?=?accept(sListen,?(struct?sockaddr?*)&client,?&iaddrSize);g_bNewConnectionArrived?=?TRUE;printf("Accepted?client:%s:%d\n",?inet_ntoa(client.sin_addr),?ntohs(client.sin_port));} } DWORD?WINAPI?WorkerThread(LPVOID?lpParam) {LPPER_IO_OPERATION_DATA?lpPerIOData?=?NULL;while?(TRUE){if?(g_bNewConnectionArrived){//?Launch?an?asynchronous?operation?for?new?arrived?connectionlpPerIOData?=?(LPPER_IO_OPERATION_DATA)HeapAlloc(GetProcessHeap(),?HEAP_ZERO_MEMORY,?sizeof(PER_IO_OPERATION_DATA));lpPerIOData->Buffer.len?=?MSGSIZE;lpPerIOData->Buffer.buf?=?lpPerIOData->szMessage;lpPerIOData->sClient?=?g_sNewClientConnection;WSARecv(lpPerIOData->sClient,?&lpPerIOData->Buffer,1,&lpPerIOData->NumberOfBytesRecvd,&lpPerIOData->Flags,&lpPerIOData->overlap,CompletionROUTINE);??????g_bNewConnectionArrived?=?FALSE;}SleepEx(1000,?TRUE);}return?0; } void?CALLBACK?CompletionROUTINE(DWORD?dwError,DWORD?cbTransferred,LPWSAOVERLAPPED?lpOverlapped,DWORD?dwFlags) {LPPER_IO_OPERATION_DATA?lpPerIOData?=?(LPPER_IO_OPERATION_DATA)lpOverlapped;if?(dwError?!=?0?||?cbTransferred?==?0){//?Connection?was?closed?by?clientclosesocket(lpPerIOData->sClient);HeapFree(GetProcessHeap(),?0,?lpPerIOData);}else{lpPerIOData->szMessage[cbTransferred]?=?'\0';send(lpPerIOData->sClient,?lpPerIOData->szMessage,?cbTransferred,?0);//?Launch?another?asynchronous?operationmemset(&lpPerIOData->overlap,?0,?sizeof(WSAOVERLAPPED));lpPerIOData->Buffer.len?=?MSGSIZE;lpPerIOData->Buffer.buf?=?lpPerIOData->szMessage;????WSARecv(lpPerIOData->sClient,&lpPerIOData->Buffer,1,&lpPerIOData->NumberOfBytesRecvd,&lpPerIOData->Flags,&lpPerIOData->overlap,CompletionROUTINE);} }

用完成例程來實現重疊I/O比用事件通知簡單得多。在這個模型中，主線程只用不停的接受連接即可；輔助線程判斷有沒有新的客戶端連接被建立，如果有，就為那個客戶端套接字激活一個異步的WSARecv操作，然后調用SleepEx使線程處于一種可警告的等待狀態，以使得I/O完成后CompletionROUTINE可以被內核調用。如果輔助線程不調用SleepEx，則內核在完成一次I/O操作后，無法調用完成例程（因為完成例程的運行應該和當初激活WSARecv異步操作的代碼在同一個線程之內）。
??? ????完成例程內的實現代碼比較簡單，它取出接收到的數據，然后將數據原封不動的發送給客戶端，最后重新激活另一個WSARecv異步操作。注意，在這里用到了“尾隨數據”。我們在調用WSARecv的時候，參數lpOverlapped實際上指向一個比它大得多的結構PER_IO_OPERATION_DATA，這個結構除了WSAOVERLAPPED以外，還被我們附加了緩沖區的結構信息，另外還包括客戶端套接字等重要的信息。這樣，在完成例程中通過參數lpOverlapped拿到的不僅僅是WSAOVERLAPPED結構，還有后邊尾隨的包含客戶端套接字和接收數據緩沖區等重要信息。這樣的C語言技巧在我后面介紹完成端口的時候還會使用到。

五.完成端口模型
??? ????“完成端口”模型是迄今為止最為復雜的一種I/O模型。然而，假若一個應用程序同時需要管理為數眾多的套接字，那么采用這種模型，往往可以達到最佳的系統性能！但不幸的是，該模型只適用于Windows NT和Windows 2000操作系統。因其設計的復雜性，只有在你的應用程序需要同時管理數百乃至上千個套接字的時候，而且希望隨著系統內安裝的CPU數量的增多，應用程序的性能也可以線性提升，才應考慮采用“完成端口”模型。要記住的一個基本準則是，假如要為Windows NT或Windows 2000開發高性能的服務器應用，同時希望為大量套接字I/O請求提供服務（Web服務器便是這方面的典型例子），那么I/O完成端口模型便是最佳選擇！
??? ????完成端口模型是我最喜愛的一種模型。雖然其實現比較復雜（其實我覺得它的實現比用事件通知實現的重疊I/O簡單多了），但其效率是驚人的。完成端口模型在多連接（成千上萬）的情況下，僅僅依靠一兩個輔助線程，就可以達到非常高的吞吐量。

#include?<WINSOCK2.H> #include?<stdio.h> #define?PORT????5150 #define?MSGSIZE?1024 #pragma?comment(lib,?"ws2_32.lib") typedef?enum {RECV_POSTED }OPERATION_TYPE; typedef?struct {WSAOVERLAPPED??overlap;WSABUF?????????Buffer;char???????????szMessage[MSGSIZE];DWORD??????????NumberOfBytesRecvd;DWORD??????????Flags;OPERATION_TYPE?OperationType; }PER_IO_OPERATION_DATA,?*LPPER_IO_OPERATION_DATA; DWORD?WINAPI?WorkerThread(LPVOID); int?main() {WSADATA?????????????????wsaData;SOCKET??????????????????sListen,?sClient;SOCKADDR_IN?????????????local,?client;DWORD???????????????????i,?dwThreadId;int?????????????????????iaddrSize?=?sizeof(SOCKADDR_IN);HANDLE??????????????????CompletionPort?=?INVALID_HANDLE_VALUE;SYSTEM_INFO?????????????systeminfo;LPPER_IO_OPERATION_DATA?lpPerIOData?=?NULL;//?Initialize?Windows?Socket?libraryWSAStartup(0x0202,?&wsaData);//?Create?completion?portCompletionPort?=?CreateIoCompletionPort(INVALID_HANDLE_VALUE,?NULL,?0,?0);//?Create?worker?threadGetSystemInfo(&systeminfo);for?(i?=?0;?i?<?systeminfo.dwNumberOfProcessors;?i++){CreateThread(NULL,?0,?WorkerThread,?CompletionPort,?0,?&dwThreadId);}//?Create?listening?socketsListen?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);//?Bindlocal.sin_addr.S_un.S_addr?=?htonl(INADDR_ANY);local.sin_family?=?AF_INET;local.sin_port?=?htons(PORT);bind(sListen,?(struct?sockaddr?*)&local,?sizeof(SOCKADDR_IN));//?Listenlisten(sListen,?3);while?(TRUE){//?Accept?a?connectionsClient?=?accept(sListen,?(struct?sockaddr?*)&client,?&iaddrSize);printf("Accepted?client:%s:%d\n",?inet_ntoa(client.sin_addr),?ntohs(client.sin_port));//?Associate?the?newly?arrived?client?socket?with?completion?portCreateIoCompletionPort((HANDLE)sClient,?CompletionPort,?(DWORD)sClient,?0);//?Launch?an?asynchronous?operation?for?new?arrived?connectionlpPerIOData?=?(LPPER_IO_OPERATION_DATA)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PER_IO_OPERATION_DATA));lpPerIOData->Buffer.len?=?MSGSIZE;lpPerIOData->Buffer.buf?=?lpPerIOData->szMessage;lpPerIOData->OperationType?=?RECV_POSTED;WSARecv(sClient,&lpPerIOData->Buffer,1,&lpPerIOData->NumberOfBytesRecvd,&lpPerIOData->Flags,&lpPerIOData->overlap,NULL);}PostQueuedCompletionStatus(CompletionPort,?0xFFFFFFFF,?0,?NULL);CloseHandle(CompletionPort);closesocket(sListen);WSACleanup();return?0; } DWORD?WINAPI?WorkerThread(LPVOID?CompletionPortID) {HANDLE??????????????????CompletionPort=(HANDLE)CompletionPortID;DWORD???????????????????dwBytesTransferred;SOCKET??????????????????sClient;LPPER_IO_OPERATION_DATA?lpPerIOData?=?NULL;while?(TRUE){GetQueuedCompletionStatus(CompletionPort,&dwBytesTransferred,&sClient,(LPOVERLAPPED?*)&lpPerIOData,INFINITE);if?(dwBytesTransferred?==?0xFFFFFFFF){return?0;}if?(lpPerIOData->OperationType?==?RECV_POSTED){if?(dwBytesTransferred?==?0){//?Connection?was?closed?by?clientclosesocket(sClient);HeapFree(GetProcessHeap(),?0,?lpPerIOData);????????}else{lpPerIOData->szMessage[dwBytesTransferred]?=?'\0';send(sClient,?lpPerIOData->szMessage,?dwBytesTransferred,?0);//?Launch?another?asynchronous?operation?for?sClientmemset(lpPerIOData,?0,?sizeof(PER_IO_OPERATION_DATA));lpPerIOData->Buffer.len?=?MSGSIZE;lpPerIOData->Buffer.buf?=?lpPerIOData->szMessage;lpPerIOData->OperationType?=?RECV_POSTED;WSARecv(sClient,&lpPerIOData->Buffer,1,&lpPerIOData->NumberOfBytesRecvd,&lpPerIOData->Flags,&lpPerIOData->overlap,NULL);}}}return?0; }

首先，說說主線程：
??? ????1.創建完成端口對象
??? ????2.創建工作者線程（這里工作者線程的數量是按照CPU的個數來決定的，這樣可以達到最佳性能）
??? ????3.創建監聽套接字，綁定，監聽，然后程序進入循環
??? ????4.在循環中，我做了以下幾件事情：
??? ???????????(1).接受一個客戶端連接
??? ???????????(2).將該客戶端套接字與完成端口綁定到一起(還是調用CreateIoCompletionPort，但這次的作用不同)，注意，按道理來講，此時傳遞給CreateIoCompletionPort的第三個參數應該是一個完成鍵，一般來講，程序都是傳遞一個單句柄數據結構的地址，該單句柄數據包含了和該客戶端連接有關的信息，由于我們只關心套接字句柄，所以直接將套接字句柄作為完成鍵傳遞；
??? ???????????(3).觸發一個WSARecv異步調用，這次又用到了“尾隨數據”，使接收數據所用的緩沖區緊跟在WSAOVERLAPPED對象之后，此外，還有操作類型等重要信息。
??? ????在工作者線程的循環中，我們
??? ????1.調用GetQueuedCompletionStatus取得本次I/O的相關信息（例如套接字句柄、傳送的字節數、單I/O數據結構的地址等等）
??? ????2.通過單I/O數據結構找到接收數據緩沖區，然后將數據原封不動的發送到客戶端
??? ????3.再次觸發一個WSARecv異步操作

?五種I/O模型的比較
??? ????我會從以下幾個方面來進行比較
??? ????*有無每線程64連接數限制
??? ????如果在選擇模型中沒有重新定義FD_SETSIZE宏，則每個fd_set默認可以裝下64個SOCKET。同樣的，受MAXIMUM_WAIT_OBJECTS宏的影響，事件選擇、用事件通知實現的重疊I/O都有每線程最大64連接數限制。如果連接數成千上萬，則必須對客戶端套接字進行分組，這樣，勢必增加程序的復雜度。
??? ????相反，異步選擇、用完成例程實現的重疊I/O和完成端口不受此限制。

???????*線程數
??? ????除了異步選擇以外，其他模型至少需要2個線程。一個主線程和一個輔助線程。同樣的，如果連接數大于64，則選擇模型、事件選擇和用事件通知實現的重疊I/O的線程數還要增加。

???????*實現的復雜度
??? ????我的個人看法是，在實現難度上，異步選擇<選擇<用完成例程實現的重疊I/O<事件選擇<完成端口<用事件通知實現的重疊I/O

??? ????*性能
??? ????由于選擇模型中每次都要重設讀集，在select函數返回后還要針對所有套接字進行逐一測試，我的感覺是效率比較差；完成端口和用完成例程實現的重疊I/O基本上不涉及全局數據，效率應該是最高的，而且在多處理器情形下完成端口還要高一些；事件選擇和用事件通知實現的重疊I/O在實現機制上都是采用WSAWaitForMultipleEvents，感覺效率差不多；至于異步選擇，不好比較。所以我的結論是:選擇<用事件通知實現的重疊I/O<事件選擇<用完成例程實現的重疊I/O<完成端口

轉載于:https://blog.51cto.com/20111564/1416745

總結

以上是生活随笔為你收集整理的Windows Socket五种I/O模型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： Redis-列表（List）基础
下一篇： we are the world 群星，