上一篇文章我們講了EventSelect網路模型，它已經解決了等待資料到來的這一大部分時間，但是它還有一小部分時間沒有節省下來。那就是把資料從網絡卡的緩衝區拷貝到我們應用程式的緩衝區裡邊。而這一篇的重疊IO模型就是將這一小部分的時間也給節省了下來。

首先，我們在主執行緒裡邊初始化網路環境，然後建立監聽的socket，接下來，執行繫結，監聽的操作，然後，建立一個工作者執行緒來對客戶進行服務。執行以上操作之後呢，是一個死迴圈。在這個迴圈裡邊，我們首先呼叫accept函式來對一個客戶進行連線操作。然後將該函式返回的客戶端的socket儲存到我們定義的一個全域性socket數組裡邊進去。然後對我們自定義的結構體單IO操作分配一個空間，其宣告如下：

typedef struct
{
   WSAOVERLAPPED overlap;<span style="white-space:pre">	</span>//OVERLAPPED結構，該結構裡邊有一個event事件物件
   WSABUF Buffer;<span style="white-space:pre">		</span>//WSABUF結構，裡邊有一個buf的大小，還有一個指標指向buf
   char szMessage[MSGSIZE];<span style="white-space:pre">	</span>//訊息資料
   DWORD NumberOfBytesRecvd;<span style="white-space:pre">	</span>//儲存接收到的位元組數
   DWORD Flags;<span style="white-space:pre">			</span>//標誌位
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;
 

注意，該結構體是我們自己定義的，其中第一個引數overlapped結構體是最重要的，必須把它放在第一個宣告處。因為我們要的是overlapped的地址，而其它的則是我們自己進行擴充套件的，大家也可以進行自己的擴充套件。那什麼叫做單IO操作呢，比如說你請了一個人來專門打理你的店鋪，你每天呢都會發一個資訊給這個人，資訊的內容就是叫他每天干一些指定的的事情，而這個資訊就是我們這個單IO操作這個資料結構所指定的內容。

我們在堆上給我們的單IO結構分配完空間之後呢，我們來對它進行初始化，我們把Buffer裡面的指標指向szMessage，把裡面的大小指定為szMessage的大小。然後，呼叫WSACreateEvent建立一個事件物件，將這個事件物件賦予給overlappped裡邊的事件物件。

最後，在迴圈的末尾我們呼叫WSARecv，來對資料進行接收，其宣告如下：

int WSARecv(  
  SOCKET s,                                               <span style="white-space:pre">	</span>//客戶連線的socket
  LPWSABUF lpBuffers,                                     <span style="white-space:pre">	</span>//WSABUFFER指標
  DWORD dwBufferCount,                                    <span style="white-space:pre">	</span>//Buffer的個數，一般這裡給個1
  LPDWORD lpNumberOfBytesRecvd,                           <span style="white-space:pre">	</span>//接收的位元組數
  LPDWORD lpFlags,                                        <span style="white-space:pre">	</span>//標誌位
  LPWSAOVERLAPPED lpOverlapped,                           <span style="white-space:pre">	</span>//overlaopped結構地址
  LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine  <span style="white-space:pre">	</span>//沒啥用，為NULL
);

注意，該函式是非同步的，也就是說它呼叫完就直接進行返回了，不用等待。所以整個迴圈，只有剛開始接收到一個客戶的連線之後，我們就暢通無阻的往下執行一遍，然後再回到迴圈的開始繼續等待客戶的連線。接下來，看下工作者執行緒。

工作者執行緒，也是一個死迴圈，它和我們的EventSelect一樣，剛開始也是呼叫了WSAWaitForMultipleEvents，來監控我們的socket陣列哪一個有訊號了，由於這個函式最多隻能監控64個socket，所以我們的服務端只能同時進行64個客戶的資料收發。呼叫完該函式之後，它會返回一個索引值，我們將呼叫WSAResetEvent，將我們全域性event數組裡邊那個有訊號的手動重置為無訊號狀態。因為我們用WSACreateEvent建立的事件物件是以手動重置的方式建立的。如果，不重置成無訊號的狀態，那麼就像上面我們舉得那個例子一樣，我們請的那個人，他第二天檢視資訊的時候，還會繼續的執行昨天的工作。

接下來，是我們重疊IO模型裡邊和EventSelect裡邊最大的不同點，我們會呼叫WSAGetOverlappedResult，來判斷重疊IO呼叫是否成功，其宣告如下：

BOOL WSAGetOverlappedResult(  
  SOCKET s,                      //有訊號的那個socket
  LPWSAOVERLAPPED lpOverlapped,  //overlapped結構地址
  LPDWORD lpcbTransfer,          //接收的位元組數
  BOOL fWait,                    //TRUE表示操作完成就返回
  LPDWORD lpdwFlags              //標誌位
);

這個函式的第三個引數和我們的WSARecv的第四個引數是一樣的，作業系統會改寫這個值，若該值為0表示客戶端斷開連線或該資料傳輸失敗了。如果沒有失敗，我們就將資料儲存到我們那個單IO結構裡邊的szMessage數組裡邊。然後再次呼叫WSARecv，告訴作業系統繼續幫我們監控這個socket。
以下是重疊IO的例項程式碼：

#include <winsock2.h>
#include <stdio.h>
#define PORT 6000
#define MSGSIZE 1024
#pragma comment (lib, "Ws2_32.lib")
BOOL WinSockInit()
{
	WSADATA data = {0};
	if(WSAStartup(MAKEWORD(2, 2), &data))
		return FALSE;
	if ( LOBYTE(data.wVersion) !=2 || HIBYTE(data.wVersion) != 2 ){
		WSACleanup();
		return FALSE;
	}
	return TRUE;
}

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()
{
	SOCKET sListen, sClient;
	SOCKADDR_IN local, client;
	DWORD dwThreadId;
	int iaddrSize = sizeof(SOCKADDR_IN);
	// 初始化環境
	WinSockInit();
	// 建立監聽socket
	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;

	    // 分配一個單io操作資料結構
	    g_pPerIODataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(
	    GetProcessHeap(),
	    HEAP_ZERO_MEMORY,
	    sizeof(PER_IO_OPERATION_DATA));
	    //初始化單io結構
	    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();
	    // 開始一個非同步操作
	    WSARecv(
	        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)
			Cleanup(index);//關閉客戶端連線
		else
		{
			//將資料儲存到szMessage裡邊			
			g_pPerIODataArr[index]->szMessage[cbTransferred] = '\0';
			//這裡直接就轉發回去了
			send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,cbTransferred, 0);
			// 進行另一個非同步操作
			WSARecv(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;
}