Winsock共有五种类型的套接字I/O模型，可让Winsock应用程序对I/O进行管理，它们包括： select(选择)、WSAAsyncSelect(异步选择)、WSAEventSelect(事件选择)、overlapped(重叠)、以及completion port(完成端口)。

1、Select(选择)模型

利用select函数，判断套接字上是否存在数据，或者能否向一个套接字写入数据。目的是防止应用程序在套接字处于锁定模式时，调用recv（或send）从没有数据的套接字上接收数据，*进入阻塞状态。

select参数和返回值意义如下：

int select (

 IN int nfds,                         //0,无意义

 IN OUT fd_set* readfds,     //检查可读性

 IN OUT fd_set* writefds,     //检查可写性

 IN OUT fd_set* exceptfds,  //例外数据

 IN const struct timeval* timeout);    //函数的返回时间，指针NULL一直等待

select返回fd_set中可用的套接字个数。

fd_set是一个SOCKET队列，以下宏可以对该队列进行操作：

FD_CLR( s, *set) 从队列set删除句柄s;

FD_ISSET( s, *set) 检查句柄s是否存在与队列set中;

FD_SET( s, *set )把句柄s添加到队列set中;

FD_ZERO( *set ) 把set队列初始化成空队列.

Select工作流程

1：用FD_ZERO宏来初始化我们感兴趣的fd_set。

也就是select函数的第二三四个参数。

2：用FD_SET宏来将套接字句柄分配给相应的fd_set。

如果想要检查一个套接字是否有数据需要接收，可以用FD_SET宏把套接接字句柄加入可读性检查队列中

3：调用select函数。

如果该套接字没有数据需要接收，select函数会把该套接字从可读性检查队列中删除掉，

4：用FD_ISSET对套接字句柄进行检查。

如果我们所关注的那个套接字句柄仍然在开始分配的那个fd_set里，那么说明马上可以进行相应的IO操 作。比如一个分配给select第一个参数的套接字句柄在select返回后仍然在select第一个参数的fd_set里，那么说明当前数据已经来了， 马上可以读取成功而不会被阻塞。

#include <winsock2.h>   
#include <stdio.h>   

#define PORT  5150   

#define MSGSIZE  1024   

#pragma comment(lib, "ws2_32.lib")   

int g_iTotalConn1 = 0;  
int g_iTotalConn2 = 0;   

SOCKET g_CliSocketArr1[FD_SETSIZE];  
SOCKET g_CliSocketArr2[FD_SETSIZE];  

DWORD WINAPI WorkerThread1(LPVOID lpParam);   
int CALLBACK ConditionFunc1(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData);

DWORD WINAPI WorkerThread2(LPVOID lpParam);   
int CALLBACK ConditionFunc2(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData);


int main(int argc, char* argv[])   
{   
 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_family = AF_INET;   
 local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);   
 local.sin_port = htons(PORT);   
 bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));   

 // Listen   

 listen(sListen, 3);   

 // Create worker thread   

 CreateThread(NULL, 0, WorkerThread1, NULL, 0, &dwThreadId);  
// CreateThread(NULL, 0, WorkerThread2, NULL, 0, &dwThreadId);  

 while (TRUE)    
 {     
  sClient = WSAAccept(sListen, (sockaddr*)&client, &iAddrSize, ConditionFunc1, 0);
  printf("1:Accepted client:%s:%d:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port), g_iTotalConn1);   
  g_CliSocketArr1[g_iTotalConn1++] = sClient;  
/*         
  sClient = WSAAccept(sListen, (sockaddr*)&client, &iAddrSize, ConditionFunc2, 0);
  printf("2:Accepted client:%s:%d:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port), g_iTotalConn2);   
  g_CliSocketArr2[g_iTotalConn2++] = sClient;   */

 }   
 return 0;   
}   

DWORD WINAPI WorkerThread1(LPVOID lpParam)   
{   
 int i;   
 fd_set fdread;   
 int ret;   
 struct timeval tv = {1, 0};   
 char szMessage[MSGSIZE];   
 while (TRUE)    
 {   
  FD_ZERO(&fdread);   //1清空队列
  for (i = 0; i < g_iTotalConn1; i++)    
  {   
   FD_SET(g_CliSocketArr1[i], &fdread);   //2将要检查的套接口加入队列
  }   

  // We only care read event   
  ret = select(0, &fdread, NULL, NULL, &tv);   //3查询满足要求的套接字，不满足要求，出队
  if (ret == 0)    
  {   
   // Time expired   
   continue;   
  }   

  for (i = 0; i < g_iTotalConn1; i++)    
  {   
   if (FD_ISSET(g_CliSocketArr1[i], &fdread))    //4.是否依然在队列
   {   
    // A read event happened on g_CliSocketArr   

    ret = recv(g_CliSocketArr1[i], szMessage, MSGSIZE, 0);   
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))    
    {   
    // Client socket closed   
     printf("1:Client socket %d closed.\n", g_CliSocketArr1[i]);   
     closesocket(g_CliSocketArr1[i]);   
     if (i < g_iTotalConn1-1)    
     {   
      g_CliSocketArr1[i--] = g_CliSocketArr1[--g_iTotalConn1];   
     }   
    }    
    else    
    {   
     // We reveived a message from client   
     szMessage[ret] = '\0';   
     send(g_CliSocketArr1[i], szMessage, strlen(szMessage), 0);   
    }   
   }   
  }  
 }   
} 

int CALLBACK ConditionFunc1(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData)
{
 if (g_iTotalConn1 < FD_SETSIZE)
  return CF_ACCEPT;
 else
  return CF_REJECT;
}

DWORD WINAPI WorkerThread2(LPVOID lpParam)   
{   
 int i;   
 fd_set fdread;   
 int ret;   
 struct timeval tv = {1, 0};   
 char szMessage[MSGSIZE];   
 while (TRUE)    
 {   
  FD_ZERO(&fdread);   //1清空队列
  for (i = 0; i < g_iTotalConn2; i++)    
  {   
   FD_SET(g_CliSocketArr2[i], &fdread);   //2将要检查的套接口加入队列
  }   

  // We only care read event   
  ret = select(0, &fdread, NULL, NULL, &tv);   //3查询满足要求的套接字，不满足要求，出队
  if (ret == 0)    
  {   
   // Time expired   
   continue;   
  }   

  for (i = 0; i < g_iTotalConn2; i++)    
  {   
   if (FD_ISSET(g_CliSocketArr2[i], &fdread))    //4.是否依然在队列
   {   
    // A read event happened on g_CliSocketArr   

    ret = recv(g_CliSocketArr2[i], szMessage, MSGSIZE, 0);   
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))    
    {   
     // Client socket closed   
     printf("2:Client socket %d closed.\n", g_CliSocketArr1[i]);   
     closesocket(g_CliSocketArr2[i]);   
     if (i < g_iTotalConn2-1)    
     {   
      g_CliSocketArr2[i--] = g_CliSocketArr2[--g_iTotalConn2];   
     }   
    }    
    else    
    {   
     // We reveived a message from client   
     szMessage[ret] = '\0';   
     send(g_CliSocketArr2[i], szMessage, strlen(szMessage), 0);   
    }   
   }   
  }  
 }   
} 

int CALLBACK ConditionFunc2(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData)
{
 if (g_iTotalConn2 < FD_SETSIZE)
  return CF_ACCEPT;
 else
  return CF_REJECT;
}

服务器的几个主要动作如下：

1.创建监听套接字，绑定，监听；

2.创建工作者线程；

3.创建一个套接字数组，用来存放当前所有活动的客户端套接字，每accept一个连接就更新一次数组；

4.接受客户端的连接。

这里有一点需要注意的，就是我没有重新定义FD_SETSIZE宏，所以服务器最多支持的并发连接数为64。而且，这里决不能无条件的accept,服务器应该根据当前的连接数来决定是否接受来自某个客户端的连接。 

工作者线程里面是一个死循环，一次循环完成的动作是：

1.将当前所有的客户端套接字加入到读集fdread中；

2.调用select函数；

3.查看某个套接字是否仍然处于读集中，如果是，则接收数据。如果接收的数据长度为0，或者发生WSAECONNRESET错误，则表示客户端套接字主动关闭，这时需要将服务器中对应的套接字所绑定的资源释放掉，然后调整我们的套接字数组（将数组中最后一个套接字挪到当前的位置上）

除了需要有条件接受客户端的连接外，还需要在连接数为0的情形下做特殊处理，因为如果读集中没有任何套接字，select函数会立刻返回，这将导致工作者线程成为一个毫无停顿的死循环，CPU的占用率马上达到100%。

关系到套接字列表的操作都需要使用循环,在轮询的时候,需要遍历一次,再新的一轮开始时,将列表加入队列又需要遍历一次.也就是说,Select在工作一次时,需要至少遍历2次列表,这是它效率较低的原因之一.在大规模的网络连接方面,还是推荐使用IOCP或EPOLL模型.但是Select模型可以使用在诸如对战类游戏上,比如类似星际这种,因为它小巧易于实现,而且对战类游戏的网络连接量并不大.

对于Select模型想要突破Windows 64个限制的话,可以采取分段轮询,一次轮询64个.例如套接字列表为128个,在第一次轮询时,将前64个放入队列中用Select进行状态查询,待本次操作全部结束后.将后64个再加入轮询队列中进行轮询处理.这样处理需要在非阻塞式下工作.以此类推,Select也能支持无限多个.

注意：

1.那个最大的连接数是指每一个线程可以处理的连接数，当你有多个线程时，连接数是可以无限增长的，不过此时的效率就比较低。

2.关于发送操作writefds的问题，当套接字成功连接或者一个套接字刚刚成功接收信息时都会调用。

3.我们通常会创建一个套接字来进行监听，之后用accept返回的套接字进行通信。这里要注意一点，用于监听的套接字在没有新连接时也会进行writefds的操作。

2、WSAAsyncSelect模型

WSAAsyncSelect模型允许应用程序以Windows消息的方式接收网络事件通知。许多对性能要求不高的网络应用程序都采用WSAAsyncSelect模型，MFC的CSocket类也使用了它。

       WSAAsyncSelect自动把套接字设为非阻塞模式，并且为套接字绑定一个窗口句柄，当有网络事件发生时，便向这个窗口发送消息。

#include <winsock2.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是最简单的一种WinsockI/O模型（之所以说它简单是因为一个主线程就搞定了）。使用Raw Windows API写过窗口类应用程序的人应该都能看得懂。这里，我们需要做的仅仅是：
1.在WM_CREATE消息处理函数中，初始化WindowsSocket library，创建监听套接字，绑定，监听，并且调用WSAAsyncSelect函数表示我们关心在监听套接字上发生的FD_ACCEPT事件；
2.自定义一个消息WM_SOCKET，一旦在我们所关心的套接字（监听套接字和客户端套接字）上发生了某个事件，系统就会调用WndProc并且message参数被设置为WM_SOCKET；
3.在WM_SOCKET的消息处理函数中，分别对FD_ACCEPT、FD_READ和FD_CLOSE事件进行处理；
4.在窗口销毁消息(WM_DESTROY)的处理函数中，我们关闭监听套接字，清除WindowsSocket library

下面这张用于WSAAsyncSelect函数的网络事件类型表可以让你对各个网络事件有更清楚的认识：
表1

3、WSAEventSelect模型

WSAEventSelect模型类似WSAAsynSelect模型，但最主要的区别是网络事件发生时会被发送到一个事件对象句柄，而不是发送到一个窗口。这样可能更加的好，对于服务器端的程序来说。

使用步骤如下：

a、创建事件对象来接收网络事件：
WSAEVENT WSACreateEvent( void ); 
该函数的返回值为一个事件对象句柄，它具有两种工作状态：已传信(signaled)和未传信(nonsignaled)以及两种工作模式：人工重设(manualreset)和自动重设(autoreset)。
默认未未传信的工作状态和人工重设模式。

b、将事件对象与套接字关联，同时注册事件，使事件对象的工作状态从未传信转变未已传信。 
int WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents ); 
参数介绍：
s为套接字
hEventObject为刚才创建的事件对象句柄
lNetworkEvents为掩码，定义如上面所述

c、I/O处理后，设置事件对象为未传信 
BOOL WSAResetEvent( WSAEVENT hEvent );
hEvent为事件对象
成功返回TRUE，失败返回FALSE。

d、等待网络事件来触发事件句柄的工作状态：
DWORD WSAWaitForMultipleEvents( DWORD cEvents,const WSAEVENT FAR * lphEvents,BOOL fWaitAll,DWORD dwTimeout, BOOL fAlertable );
参数介绍：
lpEvent为事件句柄数组的指针
cEvent为为事件句柄的数目，其最大值为WSA_MAXIMUM_WAIT_EVENTS 
fWaitAll指定等待类型：TRUE：当lphEvent数组重所有事件对象同时有信号时返回；
FALSE：任一事件有信号就返回。
dwTimeout为等待超时（毫秒）
fAlertable为指定函数返回时是否执行完成例程

nIndex=WSAWaitForMultipleEvents(…);
MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];

e.枚举事件的类型：
int WSAEnumNetworkEvents(
  SOCKET s,
  WSAEVENT hEventObject,
  LPWSANETWORKEVENTS lpNetworkEvents
);
参数介绍：
s为有事件发生的Socket
hEventObject为与s相关联的事件句柄
lpNetworkEvents是一个结构体：
typedef struct _WSANETWORKEVENTS {
       long lNetworkEvents;
       int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
if(lpNetWorkEvents.lNetworkEvents&FD_READ)
{
    if(lpNetWorkEvents[FD_READ_BIT]!=0)
      //发送错误
    else
     //有数据可以接收
 }

事件选择模型也比较简单，实现起来也不是太复杂，它的基本思想是将每个套接字都和一个WSAEVENT对象对应起来，并且在关联的时候指定需要关注的哪些网络事件。一旦在某个套接字上

发生了我们关注的事件（FD_READ和FD_CLOSE），与之相关联的WSAEVENT对象被Signaled。程序定义了两个全局数组，一个套接字数组，一个WSAEVENT对象数组，其大小都是

MAXIMUM_WAIT_OBJECTS（64），两个数组中的元素一一对应。

同样的，这里的程序没有考虑两个问题:
一是不能无条件的调用accept，因为我们支持的并发连接数有限。解决方法是将套接字按MAXIMUM_WAIT_OBJECTS分组，每MAXIMUM_WAIT_OBJECTS个套接字一组，
每一组分配一个工作者线程；或者采用WSAAccept代替accept，并回调自己定义的ConditionFunction。
第二个问题是没有对连接数为0的情形做特殊处理，程序在连接数为0的时候CPU占用率为100%。 
0连接时，g_iTotalConn= 0;
也即
WSAWaitForMultipleEvents(0, g_CliEventArr, FALSE, 1000, FALSE);
应该是一直循环ret ==WSA_WAIT_FAILED 
WSAGetLastError()=WSA_INVALID_PARAMETER

SOCKET    Socket[WSA_MAXIMUM_WAIT_EVENTS];
WSAEVENT  Event[WSA_MAXINUM_WAIT_EVENTS];
SOCKET    Accept, Listen;
DWORD     EventTotal = 0;
DWORD     Index;

//Set up a TCP socket for listening on port 5150
Listen = socket(PF_INET,SOCK_STREAM,0);

InternetAddr.sin_family      = AF_INET;
InternetAddr.sin_addr.s_addr = htonl(INADDR_ANY);
InternetAddr.sin_port        = htons(5150);

bind(Listen,(PSOCKADDR) &InternetAddr,sizeof(InternetAddr));

NewEvent = WSACreateEvent();

WSAEventSelect(Listen,NewEvnet,FD_ACCEPT|FD_CLOSE);

listen(Listen,5);

Socket[EventTotal] = Listen;
Event[EventTotal] = NewEvent;
EventTotal++;

while (TRUE)
{
 //Wait for network events on all sockets
 Index = WSAWaitForMultipleEvents(EventTotal,EventArray,FALSE,WSA_INFINITE,FALSE);

 WSAEnumNewWorkEvents(SocketArray[Index-WSA_WAIT_EVENT_0],
	 EventArray[Index-WSA_WAIT_EVENT_0],
	 &NetworkEvents);

 //Check for FD_ACCEPT messages
 if (NetworkEvents.lNetworkEvents & FD_ACCEPT)
 {
	 if (NetworkEvents.iErrorCode[FD_ACCEPT_BIT] !=0)
	 {
		 //Error
		 break;
	 }
	 //Accept a new connection and add it to the socket and event lists
	 Accept = accept(SocketArray[Index-WSA_WAIT_EVENT_0],NULL,NULL);

	 //We cannot process more than WSA_MAXIMUM_WAIT_EVENTS sockets ,
	 //so close the accepted socket
	 if (EventTotal > WSA_MAXIMUM_WAIT_EVENTS)
	 {
		 printf("..");
		 closesocket (Accept);
		 break;
	 }
	 NewEvent = WSACreateEvent();

	 WSAEventSelect(Accept,NewEvent,FD_READ|FD_WRITE|FD_CLOSE);

	 Event[EventTotal] = NewEvent;
	 Socket[EventTotal]= Accept;
	 EventTotal++;
	 prinrt("Socket %d connect/n",Accept);
 }
 //Process FD_READ notification
 if (NetworkEvents.lNetwoAD)rkEvents & FD_RE
 {
	 if (NetworkEvents.iErrorCode[FD_READ_BIT !=0])
	 {
		 //Error
		 break;
	 }

	 //Read data from the socket
	 recv(Socket[Index-WSA_WAIT_EVENT_0],buffer,sizeof(buffer),0);
 }
 //process FD_WRITE notitication
 if (NetworkEvents.lNetworkEvents & FD_WRITE)
 {
	 if (NetworkEvents.iErrorCode[FD_WRITE_BIT] !=0)
	 {
		 //Error
		 break;
	 }
	 send(Socket[Index-WSA_WAIT_EVENT_0],buffer,sizeof(buffer),0);
 }
 if (NetworkEvents.lNetworkEvents & FD_CLOSE)
 {
	 if(NetworkEvents.iErrorCode[FD_CLOSE_BIT] !=0)
	 {
		 //Error
		 break;
	 }
	 closesocket (Socket[Index-WSA_WAIT_EVENT_0]);
	 //Remove socket and associated event from the Socket and Event arrays and
	 //decrement eventTotal
	 CompressArrays(Event,Socket,& EventTotal);
 }
}

4、overlapped(重叠) I/O

5、完成端口

HANDLE CreateIoCompletionPort(
    HANDLE FileHandle,
    HANDLE ExistingCompletionPort,
    ULONG_PTR CompletionKey,
    DWORD NumberOfConcurrentThreads
);

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

BOOL GetQueuedCompletionStatus(
    HANDLE CompletionPort,
    LPDWORD lpNumberOfBytes,
    PULONG_PTR lpCompletionKey,
    LPOVERLAPPED* lpOverlapped,
    DWORD dwMilliseconds
);

typedef struct
{
    OVERLAPPED Overlapped;
    WSABUF     DataBuf;
    CHAR       Buffer[DATA_BUFSIZE];
    BOOL       OperationType;
}PER_IO_OPERATION_DATA

PER_IO_OPERATION_DATA PerIoData;
// 可像下面这样调用一个函数
  WSARecv(socket, ..., (OVERLAPPED *)&PerIoData);
// 或像这样
  WSARecv(socket, ..., &(PerIoData.Overlapped));

PostQueuedCompletionStatus函数的定义：
BOOL PostQueuedCompletionStatus(
    HANDLE CompletionPort,
    DWORD dwNumberOfBytesTransferred,
    ULONG_PTR dwCompletionKey,
    LPOVERLAPPED lpOverlapped
);

Winsock I/O 模型详解