重疊I/O模型分析

一． 重疊模型的優點 

1. 可以運行在支持Winsock2的所有Windows平臺 ,而不像完成端口只是支持NT系統。 

2. 比起阻塞、select、WSAAsyncSelect以及WSAEventSelect等模型，重疊I/O(Overlapped I/O)模型使應用程序能達到更佳的系統性能。 

因爲它和這4種模型不同的是，使用重疊模型的應用程序通知緩衝區收發系統直接使用數據，也就是說，如果應用程序投遞了一個10KB大小的緩衝區來接收數據，且數據已經到達套接字，則該數據將直接被拷貝到投遞的緩衝區。 

而這4種模型種，數據到達並拷貝到單套接字接收緩衝區中，此時應用程序會被告知可以讀入的容量。當應用程序調用接收函數之後，數據才從單套接字緩衝區拷貝到應用程序的緩衝區，差別就體現出來了。 

3. 從《windows網絡編程》中提供的試驗結果中可以看到，在使用了P4 1.7G Xero處理器(CPU很強啊)以及768MB的迴應服務器中，最大可以處理4萬多個SOCKET連接，在處理1萬2千個連接的時候CPU佔用率才40% 左右 ―― 非常好的性能，已經直逼完成端口了^_^ 


二． 重疊模型的基本原理 

說了這麼多的好處，你一定也躍躍欲試了吧，不過我們還是要先提一下重疊模型的基本原理。 

概括一點說，重疊模型是讓應用程序使用重疊數據結構(WSAOVERLAPPED)，一次投遞一個或多個Winsock I/O請求。針對這些提交的請求，在它們完成之後，應用程序會收到通知，於是就可以通過自己另外的代碼來處理這些數據了。 

需要注意的是，有兩個方法可以用來管理重疊IO請求的完成情況（就是說接到重疊操作完成的通知）： 

1. 事件對象通知(event object notification)  

2. 完成例程(completion routines) ,注意，這裏並不是完成端口 

而本文只是講述如何來使用事件通知的的方法實現重疊IO模型，完成例程的方法準備放到下一篇講 ：） (內容太多了，一篇寫不完啊) ，如沒有特殊說明，本文的重疊模型默認就是指的基於事件通知的重疊模型。 

既然是基於事件通知，就要求將Windows事件對象與WSAOVERLAPPED結構關聯在一起（WSAOVERLAPPED結構中專門有對應的參數），通俗一點講，就是。。。。對了，忘了說了，既然要使用重疊結構，我們常用的send, sendto, recv, recvfrom也都要被WSASend, WSASendto, WSARecv, WSARecvFrom替換掉了， 它們的用法我後面會講到，這裏只需要注意一點，它們的參數中都有一個Overlapped參數，我們可以假設是把我們的WSARecv這樣的操作操作“綁定”到這個重疊結構上，提交一個請求，其他的事情就交給重疊結構去操心，而其中重疊結構又要與Windows的事件對象“綁定”在一起，這樣我們調用完WSARecv以後就可以“坐享其成”，等到重疊操作完成以後，自然會有與之對應的事件來通知我們操作完成，然後我們就可以來根據重疊操作的結果取得我們想要德數據了。  

也許說了半天你還是不大明白，那就繼續往後面看吧。。。。。。。-_-b，語言表達能力有限啊~~~ 

三． 關於重疊模型的基礎知識 

下面來介紹並舉例說明一下編寫重疊模型的程序中將會使用到的幾個關鍵函數。 

1. WSAOVERLAPPED結構 

這個結構自然是重疊模型裏的核心，它是這麼定義的 

typedef struct _WSAOVERLAPPED { 

  DWORD Internal; 

  DWORD InternalHigh; 

  DWORD Offset; 

  DWORD OffsetHigh; 

  WSAEVENT hEvent;      // 唯一需要關注的參數，用來關聯WSAEvent對象 

} WSAOVERLAPPED, *LPWSAOVERLAPPED; 

我們需要把WSARecv等操作投遞到一個重疊結構上，而我們又需要一個與重疊結構“綁定”在一起的事件對象來通知我們操作的完成，看到了和hEvent參數，不用我說你們也該知道如何來來把事件對象綁定到重疊結構上吧？大致如下： 

WSAEVENT event;                   // 定義事件 

WSAOVERLAPPED AcceptOverlapped ; // 定義重疊結構 

event = WSACreateEvent();         // 建立一個事件對象句柄 

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED)); // 初始化重疊結構 

AcceptOverlapped.hEvent = event;    // Done !！ 


2. WSARecv系列函數 

在重疊模型中，接收數據就要靠它了，它的參數也比recv要多，因爲要用刀重疊結構嘛，它是這樣定義的： 

int WSARecv( 
        SOCKET s,                      // 當然是投遞這個操作的套接字 
      LPWSABUF lpBuffers,          // 接收緩衝區，與Recv函數不同 

      // 這裏需要一個由WSABUF結構構成的數組 
      DWORD dwBufferCount,        // 數組中WSABUF結構的數量 
      LPDWORD lpNumberOfBytesRecvd,  // 如果接收操作立即完成，這裏會返回函數調用所接收到的字節數 
      LPDWORD lpFlags,             // 說來話長了，我們這裏設置爲0 即可 
      LPWSAOVERLAPPED lpOverlapped,  // “綁定”的重疊結構 
      LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine   // 完成例程中將會用到的參數，我們這裏設置爲 NULL 
           ); 

返回值： 
   WSA_IO_PENDING ： 最常見的返回值，這是說明我們的WSARecv操作成功了，但是I/O操作還沒有完成，所以我們就需要綁定一個事件來通知我們操作何時完成 

舉個例子：(變量的定義順序和上面的說明的順序是對應的，下同) 

SOCKET s; 

WSABUF DataBuf;           // 定義WSABUF結構的緩衝區 

// 初始化一下DataBuf 

#define DATA_BUFSIZE 5096 

char buffer[DATA_BUFSIZE]; 

ZeroMemory(buffer, DATA_BUFSIZE); 

DataBuf.len = DATA_BUFSIZE; 

DataBuf.buf = buffer; 

DWORD dwBufferCount = 1, dwRecvBytes = 0, Flags = 0; 

// 建立需要的重疊結構 

WSAOVERLAPPED AcceptOverlapped ;// 如果要處理多個操作，這裏當然需要一個 

// WSAOVERLAPPED數組 

WSAEVENT event;     // 如果要多個事件，這裏當然也需要一個WSAEVENT數組 

// 需要注意的是可能一個SOCKET同時會有一個以上的重疊請求， 

//  也就會對應一個以上的WSAEVENT 

Event = WSACreateEvent(); 

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED)); 

AcceptOverlapped.hEvent = event;     // 關鍵的一步，把事件句柄“綁定”到重疊結構上 

// 作了這麼多工作，終於可以使用WSARecv來把我們的請求投遞到重疊結構上了 
WSARecv(s, &DataBuf, dwBufferCount, &dwRecvBytes,&Flags, &AcceptOverlapped, NULL); 

其他的函數我這裏就不一一介紹了，因爲我們畢竟還有MSDN這麼個好幫手，而且在講後面的完成例程和完成端口的時候我還會講到一些 ^_^ 

第二章 
3. WSAWaitForMultipleEvents函數 
熟悉WSAEventSelect模型的朋友對這個函數肯定不會陌生，不對，其實大家都不應該陌生，這個函數與線程中常用的WaitForMultipleObjects函數有些地方還是比較像的，因爲都是在等待某個事件的觸發嘛。 

因爲我們需要事件來通知我們重疊操作的完成，所以自然需要這個等待事件的函數與之配套。 

DWORD WSAWaitForMultipleEvents( 
        DWORD cEvents,                        // 等候事件的總數量 
      const WSAEVENT* lphEvents,           // 事件數組的指針 
      BOOL fWaitAll,          // 這個要多說兩句： 
                           // 如果設置爲 TRUE，則事件數組中所有事件被傳信的時候函數纔會返回 
                           // FALSE則任何一個事件被傳信函數都要返回 
                           // 我們這裏肯定是要設置爲FALSE的 
      DWORD dwTimeout,    // 超時時間，如果超時，函數會返回 WSA_WAIT_TIMEOUT 
                                          // 如果設置爲0，函數會立即返回 
                            // 如果設置爲 WSA_INFINITE只有在某一個事件被傳信後纔會返回 
                            // 在這裏不建議設置爲WSA_INFINITE，因爲。。。後面再講吧..-_-b 
         BOOL fAlertable       // 在完成例程中會用到這個參數，這裏我們先設置爲FALSE 
                                ); 

返回值： 
   WSA_WAIT_TIMEOUT ：最常見的返回值，我們需要做的就是繼續Wait 
    WSA_WAIT_FAILED ： 出現了錯誤，請檢查cEvents和lphEvents兩個參數是否有效 

如果事件數組中有某一個事件被傳信了，函數會返回這個事件的索引值，但是這個索引值需要減去預定義值 WSA_WAIT_EVENT_0纔是這個事件在事件數組中的位置。 

具體的例子就先不在這裏舉了，後面還會講到 

注意：WSAWaitForMultipleEvents函數只能支持由WSA_MAXIMUM_WAIT_EVENTS對象定義的一個最大值，是 64，就是說WSAWaitForMultipleEvents只能等待64個事件，如果想同時等待多於64個事件，就要 創建額外的工作者線程，就不得不去管理一個線程池，這一點就不如下一篇要講到的完成例程模型了。 

  

4. WSAGetOverlappedResult函數 

既然我們可以通過WSAWaitForMultipleEvents函數來得到重疊操作完成的通知，那麼我們自然也需要一個函數來查詢一下重疊操作的結果，定義如下 

BOOL WSAGetOverlappedResult( 
       SOCKET s,                   // SOCKET，不用說了 
     LPWSAOVERLAPPED lpOverlapped,  // 這裏是我們想要查詢結果的那個重疊結構的指針 
     LPDWORD lpcbTransfer,      // 本次重疊操作的實際接收(或發送)的字節數 
     BOOL fWait,                // 設置爲TRUE，除非重疊操作完成，否則函數不會返回 
                           // 設置FALSE，而且操作仍處於掛起狀態，那麼函數就會返回FALSE 
                                       // 錯誤爲WSA_IO_INCOMPLETE 
                                       // 不過因爲我們是等待事件傳信來通知我們操作完成，所以我們這裏設置成什麼都沒有作用…..-_-b  別仍雞蛋啊，我也想說得清楚一些… 
     LPDWORD lpdwFlags       // 指向DWORD的指針，負責接收結果標誌 
                        ); 

這個函數沒什麼難的，這裏我們也不需要去關注它的返回值，直接把參數填好調用就可以了，這裏就先不舉例了 

唯一需要注意一下的就是如果WSAGetOverlappedResult完成以後，第三個參數返回是 0 ，則說明通信對方已經關閉連接，我們這邊的SOCKET, Event之類的也就可以關閉了。 

  

四.實現重疊模型的步驟 

作了這麼多的準備工作，費了這麼多的筆墨，我們終於可以開始着手編碼了。其實慢慢的你就會明白，要想透析重疊結構的內部原理也許是要費點功夫，但是隻是學會如何來使用它，卻是真的不難，唯一需要理清思路的地方就是和大量的客戶端交互的情況下，我們得到事件通知以後，如何得知是哪一個重疊操作完成了，繼而知道究竟該對哪一個套接字進行處理，應該去哪個緩衝區中的取得數據，everything will be OK^_^。 

下面我們配合代碼，來一步步的講解如何親手完成一個重疊模型。 

第三章 

【第一步】定義變量 

#define DATA_BUFSIZE     4096          // 接收緩衝區大小 

SOCKET         ListenSocket,             // 監聽套接字 

AcceptSocket;             // 與客戶端通信的套接字 

WSAOVERLAPPED  AcceptOverlapped;     // 重疊結構一個 

WSAEVENT  EventArray[WSA_MAXIMUM_WAIT_EVENTS];   

// 用來通知重疊操作完成的事件句柄數組 

WSABUF     DataBuf[DATA_BUFSIZE] ;       

DWORD     dwEventTotal = 0,            // 程序中事件的總數 

          dwRecvBytes = 0,            // 接收到的字符長度 

          Flags = 0;                    // WSARecv的參數 

  

  

【第二步】創建一個套接字，開始在指定的端口上監聽連接請求 

和其他的SOCKET初始化全無二致，直接照搬即可，在此也不多費脣舌了，需要注意的是爲了一目瞭然，我去掉了錯誤處理，平常可不要這樣啊，儘管這裏出錯的機率比較小。 

WSADATA wsaData; 

WSAStartup(MAKEWORD(2,2),&wsaData); 

  

ListenSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);  //創建TCP套接字 

SOCKADDR_IN ServerAddr;                           //分配端口及協議族並綁定 

ServerAddr.sin_family=AF_INET;                                 

ServerAddr.sin_addr.S_un.S_addr  =htonl(INADDR_ANY);           

ServerAddr.sin_port=htons(11111); 

bind(ListenSocket,(LPSOCKADDR)&ServerAddr, sizeof(ServerAddr)); // 綁定套接字 

listen(ListenSocket, 5);                                   //開始監聽 

  

【第三步】接受一個入站的連接請求 

一個accept就完了, 至於AcceptEx的使用，在完成端口中我會講到，這裏就先不一次灌輸這麼多了，不消化啊^_^ 

AcceptSocket = accept (ListenSocket, NULL,NULL) ;  

當然，這裏是我偷懶，如果想要獲得連入客戶端的信息，accept的後兩個參數就不要用NULL，而是這樣 

SOCKADDR_IN ClientAddr;                   // 定義一個客戶端得地址結構作爲參數 

int addr_length=sizeof(ClientAddr); 

AcceptSocket = accept(ListenSocket,(SOCKADDR*)&ClientAddr, &addr_length); 

// 於是乎，我們就可以輕鬆得知連入客戶端的信息了 
LPCTSTR lpIP =  inet_ntoa(ClientAddr.sin_addr);      // IP 

UINT nPort = ClientAddr.sin_port;                    // Port 

  

【第四步】建立並初始化重疊結構 

爲連入的這個套接字新建立一個WSAOVERLAPPED重疊結構，並且象前面講到的那樣，爲這個重疊結構從事件句柄數組裏挑出一個空閒的對象句柄“綁定”上去。 

// 創建一個事件 
// dwEventTotal可以暫時先作爲Event數組的索引 
EventArray[dwEventTotal] = WSACreateEvent();       

ZeroMemory(&AcceptOverlapped, sizeof(WSAOVERLAPPED));      // 置零 

AcceptOverlapped.hEvent = EventArray[dwEventTotal];            // 關聯事件 

  
char buffer[DATA_BUFSIZE]; 

ZeroMemory(buffer, DATA_BUFSIZE); 

DataBuf.len = DATA_BUFSIZE; 

DataBuf.buf = buffer;                          // 初始化一個WSABUF結構 

dwEventTotal ++;                              // 總數加一 

  

【第五步】以WSAOVERLAPPED結構爲參數，在套接字上投遞WSARecv請求 

各個變量都已經初始化OK以後，我們就可以開始Socket操作了，然後讓WSAOVERLAPPED結構來替我們管理I/O 請求，我們只用等待事件的觸發就OK了。 

if(WSARecv(AcceptSocket ,&DataBuf,1,&dwRecvBytes,&Flags,& AcceptOverlapped, NULL) == SOCKET_ERROR) 
{  
   // 返回WSA_IO_PENDING是正常情況，表示IO操作正在進行，不能立即完成 
   // 如果不是WSA_IO_PENDING錯誤，就大事不好了~~~~~~！！！ 

      if(WSAGetLastError() != WSA_IO_PENDING)     
      { 
            // 那就只能關閉大吉了 
            closesocket(AcceptSocket); 
            WSACloseEvent(EventArray[dwEventTotal]); 
      } 
} 

  

【第六步】 用WSAWaitForMultipleEvents函數等待重疊操作返回的結果 

  我們前面已經給WSARecv關聯的重疊結構賦了一個事件對象句柄，所以我們這裏要等待事件對象的觸發與之配合，而且需要根據WSAWaitForMultipleEvents函數的返回值來確定究竟事件數組中的哪一個事件被觸發了，這個函數的用法及返回值請參考前面的基礎知識部分。 

DWORD dwIndex; 

// 等候重疊I/O調用結束 

// 因爲我們把事件和Overlapped綁定在一起，重疊操作完成後我們會接到事件通知 

dwIndex = WSAWaitForMultipleEvents(dwEventTotal,  

EventArray ,FALSE ,WSA_INFINITE,FALSE); 

// 注意這裏返回的Index並非是事件在數組裏的Index，而是需要減去WSA_WAIT_EVENT_0 

dwIndex = dwIndex – WSA_WAIT_EVENT_0; 

  

【第七步】使用WSAResetEvent函數重設當前這個用完的事件對象 

事件已經被觸發了之後，它對於我們來說已經沒有利用價值了，所以要將它重置一下留待下一次使用，很簡單，就一步，連返回值都不用考慮 

WSAResetEvent(EventArray[dwIndex]); 

  

【第八步】使用WSAGetOverlappedResult函數取得重疊調用的返回狀態 

  這是我們最關心的事情，費了那麼大勁投遞的這個重疊操作究竟是個什麼結果呢？其實對於本模型來說，唯一需要檢查一下的就是對方的Socket連接是否已經關閉了 

DWORD dwBytesTransferred; 

WSAGetOverlappedResult( AcceptSocket, AcceptOverlapped , 

&dwBytesTransferred, FALSE, &Flags); 

// 先檢查通信對方是否已經關閉連接 

// 如果==0則表示連接已經，則關閉套接字 

if(dwBytesTransferred == 0) 
{ 
      closesocket(AcceptSocket); 
      WSACloseEvent(EventArray[dwIndex]);    // 關閉事件 
    return; 
} 

  

【第九步】“享受”接收到的數據 

如果程序執行到了這裏，那麼就說明一切正常，WSABUF結構裏面就存有我們WSARecv來的數據了，終於到了盡情享用成果的時候了！喝杯茶，休息一下吧~~~^_^ 

DataBuf.buf就是一個char*字符串指針，聽憑你的處理吧，我就不多說了 

  

【第十步】同第五步一樣，在套接字上繼續投遞WSARecv請求，重複步驟 6 ~ 9 

這樣一路作下來，我們終於可以從客戶端接收到數據了，但是回想起來，呀~~~~~，這樣豈不是隻能收到一次數據，然後程序不就Over了？…….-_-b  所以我們接下來不得不重複一遍第四步和第五步的工作，再次在這個套接字上投遞另一個WSARecv請求，並且使整個過程循環起來，are u clear？？ 

     大家可以參考我的代碼，在這裏就先不寫了，因爲各位都一定比我smart，領悟了關鍵所在以後，稍作思考就可以靈活變通了。 

  

  

五。多客戶端情況的注意事項 

     完成了上面的循環以後，重疊模型就已經基本上搭建好了80%了，爲什麼不是100%呢？因爲仔細一回想起來，呀~~~~~~~，這樣豈不是隻能連接一個客戶端？？是的，如果只處理一個客戶端，那重疊模型就半點優勢也沒有了，我們正是要使用重疊模型來處理多個客戶端。 所以我們不得不再對結構作一些改動。 

1． 首先，肯定是需要一個SOCKET數組 ,分別用來和每一個SOCKET通信 

其次，因爲重疊模型中每一個SOCKET操作都是要“綁定”一個重疊結構的，所以需要爲每一個SOCKET操作搭配一個WSAOVERLAPPED結構，但是這樣說並不嚴格，因爲如果每一個SOCKET同時只有一個操作，比如WSARecv，那麼一個SOCKET就可以對應一個WSAOVERLAPPED結構，但是如果一個SOCKET上會有WSARecv 和WSASend兩個操作，那麼一個SOCKET肯定就要對應兩個WSAOVERLAPPED結構，所以有多少個SOCKET操作就會有多少個WSAOVERLAPPED結構。 

然後，同樣是爲每一個WSAOVERLAPPED結構都要搭配一個WSAEVENT事件，所以說有多少個SOCKET操作就應該有多少個WSAOVERLAPPED結構，有多少個WSAOVERLAPPED結構就應該有多少個WSAEVENT事件，最好把SOCKET – WSAOVERLAPPED – WSAEVENT三者的關聯起來，到了關鍵時刻纔會臨危不亂：） 

  

2． 不得不分作兩個線程： 

一個用來循環監聽端口，接收請求的連接，然後給在這個套接字上配合一個WSAOVERLAPPED結構投遞第一個WSARecv請求，然後進入第二個線程中等待操作完成。 

第二個線程用來不停的對WSAEVENT數組WSAWaitForMultipleEvents，等待任何一個重疊操作的完成，然後根據返回的索引值進行處理，處理完畢以後再繼續投遞另一個WSARecv請求。 

這裏需要注意一點的是，前面我是把WSAWaitForMultipleEvents函數的參數設置爲WSA_ 

INFINITE的，但是在多客戶端的時候這樣就不OK了，需要設定一個超時時間，如果等待超時了再重新WSAWaitForMultipleEvents，因爲WSAWaitForMultipleEvents函數在沒有觸發的時候是阻塞在那裏的，我們可以設想一下，這時如果監聽線程忠接入了新的連接，自然也會爲這個連接增加一個Event，但是WSAWaitForMultipleEvents還是阻塞在那裏就不會處理這個新連接的Event了。也不知道說明白了沒有。。。。。。-_-b 可能在這裏你也體會不到，真正編碼的時候就會明白了。  

  

其他還有不明白的地方可以參考我的代碼，代碼裏也有比較詳盡的註釋,  Enjoy~~~ 

不過可惜是爲了照顧大多數人，使用的是MFC的代碼，顯得代碼有些雜亂。 

  

另：只能用於 
WSASend 

WSASendTo 

WSARecv 

WSARecvFrom 

WSAIoctl 

WSARecvMsg 

AcceptEx 

ConnectEx 

TransmitFile 

TransmitPackets 

DisconnectEx 

WSANSPIoctl