Windows下重疊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
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //不過因為我們是等待事件傳信來通知我們操作完成，所以我們這裡設定成什麼都沒有作用…
　　　　　　　　　　　　　　 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);　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //開始監聽
　

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

　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？？

　　　　 大家可以參考My Code，在這裡就先不寫了，因為各位都一定比我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 可能在這裡你也體會不到，真正編碼的時候就會明白了。

其他還有不明白的地方可以參考My Code，代碼裡也有比較詳盡的注釋,　 Enjoy~~~

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

六．已知問題

　　　 　這個已知問題是說My Code中的已知問題，可不是重疊結構的已知問題：）

　　這個範例程式碼已經寫好了很久了，這兩天做最後測試的時候才發現竟然有兩個Bug，而且還不是每次都會出現，5555，我最近是實在沒有精力去改了，如果有心的朋友能修改掉這兩個Bug，那真是造福大家了，這篇文章都險些流產，我更沒有經曆去修改都快要淡忘了的代碼的Bug了，我寫在這裡提醒一下大家了，反正這個代碼也僅僅是拋磚引玉而已，而且我覺得比起代碼來還是文字比較珍貴^_^，因為重疊模型的代碼網上也還是有不少的。兩個Bug是這樣的：

1．　 多個用戶端在連續退出的時候，有時會出現異常；

2．　 有時多個用戶端的接收緩衝區竟然會重疊到一起，就是說A用戶端發送的資料後面會根有B用戶端上次發來的資料。。。。。-_-b

　　改進演算法：其實代碼中的演算法還有很多可以改進的地方，limin朋友就向我提及過幾個非常好的改進演算法，比如如何在socket數組中尋找閒置socket用來通訊，但是我並沒有加到這份代碼裡面來，因為本來重疊模型的代碼就比較雜，再加上這些東西恐怕反而會給初學者帶來困難。但是非常歡迎各位和我討論重疊模型的改進演算法以及我代碼中存在問題！^_^