如果你想在Windows平臺上構建服務器應用，那麼I/O模型是你必須考慮的。Windows操作系統提供了選擇（Select）、異步選擇（WSAAsyncSelect）、事件選擇（WSAEventSelect）、重疊I/O（Overlapped I/O）和完成端口（Completion Port)共五種I/O模型。每一種模型均適用於一種特定的應用場景。程序員應該對自己的應用需求非常明確，而且綜合考慮到程序的擴展性和可移植性等因素，作出自己的選擇。

我會以一個迴應反射式服務器（與《Windows網絡編程》第八章一樣）來介紹這五種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;

// Initialize Windows socket library

WSAStartup(0x0202, &wsaData);

// Create client socket

sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Connect to server

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 message

send(sClient, szMessage, strlen(szMessage), 0);

// Receive message

ret = recv(sClient, szMessage, MSGSIZE, 0);

szMessage[ret] = '\0';

printf("Received [%d bytes]: '%s'\n", ret, szMessage);

}

// Clean up

closesocket(sClient);

WSACleanup();

return 0;

}

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

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

一.選擇模型

Select（選擇）模型是Winsock中最常見的I/O模型。之所以稱其爲“Select模型”，是由於它的“中心思想”便是利用select函數，實現對I/O的管理。最初設計該模型時，主要面向的是某些使用UNIX操作系統的計算機，它們採用的是Berkeley套接字方案。Select模型已集成到Winsock 1.1中，它使那些想避免在套接字調用過程中被無辜“鎖定”的應用程序，採取一種有序的方式，同時進行對多個套接字的管理。由於Winsock 1.1向後兼容於Berkeley套接字實施方案，所以假如有一個Berkeley套接字應用使用了select函數，那麼從理論角度講，毋需對其進行任何修改，便可正常運行。（節選自《Windows網絡編程》第八章)

下面的這段程序就是利用選擇模型實現的Echo服務器的代碼（已經不能再精簡了）：

#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;

// Initialize Windows socket library

WSAStartup(0x0202, &wsaData);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

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

listen(sListen, 3);

// Create worker thread

CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

while (TRUE)

{

// Accept a connection

sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);

printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

// Add socket to g_CliSocketArr

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);

}

// We only care read event

ret = select(0, &fdread, NULL, NULL, &tv);

if (ret == 0)

{

// Time expired

continue;

}

for (i = 0; i < g_iTotalConn; i++)

{

if (FD_ISSET(g_CliSocketArr[i], &fdread))

{

// A read event happened on g_CliSocketArr[i]

ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);

if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))

{

// Client socket closed

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

{

// We received a message from client

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。如下所示：

int CALLBACK ConditionFunc(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData)

{

if (當前連接數 < FD_SETSIZE)

return CF_ACCEPT;

else

return CF_REJECT;

}

工作者線程裏面是一個死循環，一次循環完成的動作是：

1.將當前所有的客戶端套接字加入到讀集fdread中；

2.調用select函數；

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

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

二.異步選擇

Winsock提供了一個有用的異步I/O模型。利用這個模型，應用程序可在一個套接字上，接收以Windows消息爲基礎的網絡事件通知。具體的做法是在建好一個套接字後，調用WSAAsyncSelect函數。該模型最早出現於Winsock的1.1版本中，用於幫助應用程序開發者面向一些早期的16位Windows平臺（如Windows for Workgroups），適應其“落後”的多任務消息環境。應用程序仍可從這種模型中得到好處，特別是它們用一個標準的Windows例程（常稱爲"WndProc"），對窗口消息進行管理的時候。該模型亦得到了Microsoft Foundation Class（微軟基本類，MFC）對象CSocket的採納。（節選自《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 name

TEXT ("AsyncSelect Model"), // window caption

WS_OVERLAPPEDWINDOW, // window style

CW_USEDEFAULT, // initial x position

CW_USEDEFAULT, // initial y position

CW_USEDEFAULT, // initial x size

CW_USEDEFAULT, // initial y size

NULL, // parent window handle

NULL, // window menu handle

hInstance, // program instance handle

NULL) ; // creation parameters

ShowWindow(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 library

WSAStartup(0x0202, &wsd);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

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(local));

// Listen

listen(sListen, 3);

// Associate listening socket with FD_ACCEPT event

WSAAsyncSelect(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 client

sClient = accept(wParam, (struct sockaddr *)&client, &iAddrSize);

// Associate client socket with FD_READ and FD_CLOSE event

WSAAsyncSelect(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模型（之所以說它簡單是因爲一個主線程就搞定了）。使用Raw Windows 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

下面這張用於WSAAsyncSelect函數的網絡事件類型表可以讓你對各個網絡事件有更清楚的認識：

表1

FD_READ 應用程序想要接收有關是否可讀的通知，以便讀入數據

FD_WRITE 應用程序想要接收有關是否可寫的通知，以便寫入數據

FD_OOB 應用程序想接收是否有帶外（OOB）數據抵達的通知

FD_ACCEPT 應用程序想接收與進入連接有關的通知

FD_CONNECT 應用程序想接收與一次連接或者多點join操作完成的通知

FD_CLOSE 應用程序想接收與套接字關閉有關的通知

FD_QOS 應用程序想接收套接字“服務質量”（QoS）發生更改的通知

FD_GROUP_QOS 應用程序想接收套接字組“服務質量”發生更改的通知（現在沒什麼用處，爲未來套接字組的使用保留）

FD_ROUTING_INTERFACE_CHANGE 應用程序想接收在指定的方向上，與路由接口發生變化的通知

FD_ADDRESS_LIST_CHANGE 應用程序想接收針對套接字的協議家族，本地地址列表發生變化的通知

三.事件選擇

Winsock提供了另一個有用的異步I/O模型。和WSAAsyncSelect模型類似的是，它也允許應用程序在一個或多個套接字上，接收以事件爲基礎的網絡事件通知。對於表1總結的、由WSAAsyncSelect模型採用的網絡事件來說，它們均可原封不動地移植到新模型。在用新模型開發的應用程序中，也能接收和處理所有那些事件。該模型最主要的差別在於網絡事件會投遞至一個事件對象句柄，而非投遞至一個窗口例程。（節選自《Windows網絡編程》第八章)

還是讓我們先看代碼然後進行分析：

#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 library

WSAStartup(0x0202, &wsaData);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

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

listen(sListen, 3);

// Create worker thread

CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

while (TRUE)

{

// Accept a connection

sClient = 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 event

g_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 client

ret = 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 library

WSAStartup(0x0202, &wsaData);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

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

listen(sListen, 3);

// Create worker thread

CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

while (TRUE)

{

// Accept a connection

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;

// Allocate a PER_IO_OPERATION_DATA structure

g_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 operation

WSARecv(

g_CliSocketArr[g_iTotalConn],

&g_pPerIODataArr[g_iTotalConn]->Buffer,

&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 client

Cleanup(index);

}

else

{

// g_pPerIODataArr[index]->szMessage contains the received data

g_pPerIODataArr[index]->szMessage[cbTransferred] = '\0';

send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,\

cbTransferred, 0);

// Launch another asynchronous operation

WSARecv(

g_CliSocketArr[index],

&g_pPerIODataArr[index]->Buffer,

&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 library

WSAStartup(0x0202, &wsaData);

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

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

listen(sListen, 3)

// Create worker thread

CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

while (TRUE)

{

// Accept a connection

g_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 connection

lpPerIOData = (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,

&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 client

closesocket(lpPerIOData->sClient);

HeapFree(GetProcessHeap(), 0, lpPerIOData);

}

else

{

lpPerIOData->szMessage[cbTransferred] = '\0';

send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);

// Launch another asynchronous operation

memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));

lpPerIOData->Buffer.len = MSGSIZE;

lpPerIOData->Buffer.buf = lpPerIOData->szMessage;

WSARecv(lpPerIOData->sClient,

&lpPerIOData->Buffer,

&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完成端口模型便是最佳選擇！（節選自《Windows網絡編程》第八章）

完成端口模型是我最喜愛的一種模型。雖然其實現比較複雜（其實我覺得它的實現比用事件通知實現的重疊I/O簡單多了），但其效率是驚人的。我在T公司的時候曾經幫同事寫過一個郵件服務器的性能測試程序，用的就是完成端口模型。結果表明，完成端口模型在多連接（成千上萬）的情況下，僅僅依靠一兩個輔助線程，就可以達到非常高的吞吐量。下面我還是從代碼說起：

#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 library

WSAStartup(0x0202, &wsaData);

// Create completion port

CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

// Create worker thread

GetSystemInfo(&systeminfo);

for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)

{

CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);

}

// Create listening socket

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

// Bind

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

listen(sListen, 3);

while (TRUE)

{

// Accept a connection

sClient = 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 port

CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);

// Launch an asynchronous operation for new arrived connection

lpPerIOData = (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,

&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 client

closesocket(sClient);

HeapFree(GetProcessHeap(), 0, lpPerIOData);

}

else

{

lpPerIOData->szMessage[dwBytesTransferred] = '\0';

send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0);

// Launch another asynchronous operation for sClient

memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));

lpPerIOData->Buffer.len = MSGSIZE;

lpPerIOData->Buffer.buf = lpPerIOData->szMessage;

lpPerIOData->OperationType = RECV_POSTED;

WSARecv(sClient,

&lpPerIOData->Buffer,

&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 < 完成端口

六種模型的比喻

實現代碼：http://tangfeng.iteye.com/blog/518146

老陳有一個在外地工作的女兒，不能經常回來，老陳和她通過信件聯繫。他們的信會被郵遞員投遞到他們的信箱裏。
這和Socket模型非常類似。下面我就以老陳接收信件爲例講解Socket I/O模型~~~

一：select模型

老陳非常想看到女兒的信。以至於他每隔10分鐘就下樓檢查信箱，看是否有女兒的信~~~~~
在這種情況下，"下樓檢查信箱"然後回到樓上耽誤了老陳太多的時間，以至於老陳無法做其他工作。
select模型和老陳的這種情況非常相似：周而復始地去檢查......如果有數據......接收/發送.......

二：WSAAsyncSelect模型

後來，老陳使用了微軟公司的新式信箱。這種信箱非常先進，一旦信箱裏有新的信件，蓋茨就會給老陳打電話：喂，大爺，你有新的信件了！從此，老陳再也不必頻繁上下樓檢查信箱了，牙也不疼了，你瞅準了，藍天......不是，微軟~~~~~~~~
微軟提供的WSAAsyncSelect模型就是這個意思。

WSAAsyncSelect模型是Windows下最簡單易用的一種Socket I/O模型。使用這種模型時，Windows會把網絡事件以消息的形式通知應用程序。

三：WSAEventSelect模型

後來，微軟的信箱非常暢銷，購買微軟信箱的人以百萬計數......以至於蓋茨每天24小時給客戶打電話，累得腰痠背痛，喝蟻力神都不好使~~~~~~
微軟改進了他們的信箱：在客戶的家中添加一個附加裝置，這個裝置會監視客戶的信箱，每當新的信件來臨（#add，此處如何得知信件來臨呢？），此裝置會發出"新信件到達"聲，提醒老陳去收信。蓋茨終於可以睡覺了。

四：Overlapped I/O 事件通知模型

後來，微軟通過調查發現，老陳不喜歡上下樓收發信件，因爲上下樓其實很浪費時間。於是微軟再次改進他們的信箱。新式的信箱採用了更爲先進的技術，只要用戶告訴微軟自己的家在幾樓幾號，新式信箱會把信件直接傳送到用戶的家中，然後告訴用戶，你的信件已經放到你的家中了！老陳很高興，因爲他不必再親自收發信件了！

Overlapped I/O 事件通知模型和WSAEventSelect模型在實現上非常相似，主要區別在"Overlapped"，Overlapped模型是讓應用程序使用重疊數據結構(WSAOVERLAPPED)，一次投遞一個或多個Winsock I/O請求。這些提交的請求完成後，應用程序會收到通知。什麼意思呢？就是說，如果你想從socket上接收數據，只需要告訴系統，由系統爲你接收數據，而你需要做的只是爲系統提供一個緩衝區~~~~~
Listen線程和WSAEventSelect模型一模一樣，Recv/Send線程則完全不同：

五：Overlapped I/O 完成例程模型

老陳接收到新的信件後，一般的程序是：打開信封----掏出信紙----閱讀信件----回覆信件......爲了進一步減輕用戶負擔，微軟又開發了一種新的技術：用戶只要告訴微軟對信件的操作步驟，微軟信箱將按照這些步驟去處理信件，不再需要用戶親自拆信/閱讀/回覆了！老陳終於過上了小資生活！

Overlapped I/O 完成例程要求用戶提供一個回調函數，發生新的網絡事件的時候系統將執行這個函數：
procedure WorkerRoutine( const dwError, cbTransferred : DWORD; const
lpOverlapped : LPWSAOVERLAPPED; const dwFlags : DWORD ); stdcall;
然後告訴系統用WorkerRoutine函數處理接收到的數據：
WSARecv( m_socket, @FBuf, 1, dwTemp, dwFlag, @m_overlap, WorkerRoutine );
然後......沒有什麼然後了，系統什麼都給你做了！微軟真實體貼！

微軟信箱似乎很完美，老陳也很滿意。但是在一些大公司情況卻完全不同！這些大公司有數以萬計的信箱，每秒鐘都有數以百計的信件需要處理，以至於微軟信箱經常因超負荷運轉而崩潰！需要重新啓動！微軟不得不使出殺手鐗......
微軟給每個大公司派了一名名叫"CompletionPort"的超級機器人，讓這個機器人去處理那些信件！

"Windows NT小組注意到這些應用程序的性能沒有預料的那麼高。特別的，處理很多同時的客戶請求意味着很多線程併發地運行在系統中。因爲所有這些線程都是可運行的[沒有被掛起和等待發生什麼事]，Microsoft意識到NT內核花費了太多的時間來轉換運行線程的上下文[Context]，線程就沒有得到很多CPU時間來做它們的工作。大家可能也都感覺到並行模型的瓶頸在於它爲每一個客戶請求都創建了一個新線程。創建線程比起創建進程開銷要小，但也遠不是沒有開銷的。我們不妨設想一下：如果事先開好N個線程，讓它們在那hold[堵塞]，然後可以將所有用戶的請求都投遞到一個消息隊列中去。然後那N個線程逐一從消息隊列中去取出消息並加以處理。就可以避免針對每一個用戶請求都開線程。不僅減少了線程的資源，也提高了線程的利用率。理論上很不錯，你想我等泛泛之輩都能想出來的問題，Microsoft又怎會沒有考慮到呢?"-----摘自nonocast的《理解I/O CompletionPort》

Windows Socket五種I/O模型——代碼全攻略

一.選擇模型

二.異步選擇

三.事件選擇

四.重疊I/O模型

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

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

五.完成端口模型

六.五種I/O模型的比較

六種模型的比喻

.NET有哪些好用的定時任務調度框架

Python 將PDF轉爲PDF/A、PDF/X，以及PDF/A轉回PDF

elk3

Kafka存儲機制

aws語音呼叫調用，告警電話

深度學習框架火焰圖pprof和CUDA Nsys配置指南

爬蟲兩種繞過5s盾的方法

【轉】[C#] WebAPI 防止併發調用二（冥等性）

【轉】[SQL Server]關掉 SSMS 的 IntelliSense

號稱能打敗MLP的KAN到底行不行？數學核心原理全面解析

“池化技術”漫談 - 線程池，內存池，連接池……

Ｃ＃中窗體之間的數據傳遞

馮.諾伊曼結構VS哈佛結構

一些軟件設計的原則

內存泄露檢查

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結