了解Windows下的几种Socket I/O网络模型

本文主要讲述的是windows下的Socket I/O管理模型以及相关程序例子。主要的模型有以下几个：

一：select模型



二：WSAAsyncSelect模型



三：WSAEventSelect模型



四：OverLapped I/O 时间通知模型



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



六：完成端口 IOCP模型

为了让内容能够生动易懂，本文采用一个生活的例子来比喻各种模型的场景。

       <1>首先我们把要管理的Socket看做是 几个码头， 

      <2>Socket上面接收到的数据信息就是 船上的货物，

      <3>你是码头的负责人，负责将货品的处理。

公用的数据结构和函数：

#ifndef _DATABASE_

#define  DATA_BUFFER_SIZE 8192

/*重叠数据结构封装*/
typedef struct
{
OVERLAPPED Overlapped;
WSABUF DataBuff;
CHAR Buff[DATA_BUFFER_SIZE];
SOCKET Socket;
}PER_IO_OPERATION_DATA,* LPPER_IO_OPERATION_DATA;

/*IOCP标识封装*/
typedef struct
{
SOCKET Socket;
}PER_HANDLE_DATA,*LPPER_HANDLE_DATA;

SOCKET ServerSockInit()
{
/*初始化相关网络环境*/
WORD wVersionRequired=MAKEWORD(2, 2);
WSADATA wsData;

if(WSAStartup(wVersionRequired,&wsData)!=0)
{
return SOCKET_ERROR;
}

if(HIBYTE(wsData.wVersion) !=2 || LOBYTE(wsData.wVersion) != 2)
{
WSACleanup();
return SOCKET_ERROR;
}

/*创建服务器监听端口*/
SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);
SOCKADDR_IN sockAdd;
sockAdd.sin_family=AF_INET;
sockAdd.sin_addr.S_un.S_addr=htonl(ADDR_ANY);
sockAdd.sin_port=htons(6000);

/*绑定监听端口和设置监听队列长度*/
if (SOCKET_ERROR == bind(sockSrv,(sockaddr *)&sockAdd,sizeof(sockaddr)))
{
printf("Bind绑定sock到对应端口出错, 错误码: %d !!!",  WSAGetLastError());
}

if(SOCKET_ERROR == listen(sockSrv,5))
{
printf("Listen设置监听端口队列长度出错, 错误码: %d !!!",  WSAGetLastError());
}

return sockSrv;
}

#define _DATABASE_
#endif

一：select模型



      在这种模型下，负责人只能轮流步行去各个码头询问有没有货要上岸，好吧，没有的话就继续下一个码头。若有得话就开始负责叫人处理货物，货品上岸，装集装箱，后面还有一大堆事情。好吧，处理完了，继续去下一个码头询问。好吧，一两个码头还行，hode得住，要是成千上万个码头可要命。那效率真低。

#ifndef _SELECT_
#define _SELECT_
#include "StdAfx.h"

DWORD WINAPI SelectProcessIO(LPVOID lpParam)
{
fd_set* pfdSocketSet = (fd_set*)lpParam;	/*指针转换*/

fd_set fdReadSocketSet;						/*可读socket数组，select将已经准备好Recv,
Accept等操作的Socket投放进去*/

int nOperateCount = 0;						/*select返回值，返回可操作个数或者错误标识*/

int  nRecvResult =0;

char szDataBuff[DATA_BUFFER_SIZE];

while(TRUE)
{
/*内存重置*/
memset(&fdReadSocketSet, 0, sizeof(fdReadSocketSet));

/*将要检测读操作的所有socket复制到Read数组里面*/
fdReadSocketSet.fd_count = pfdSocketSet->fd_count;
for (int nIndex = 0; nIndex < pfdSocketSet->fd_count; ++nIndex)
{
fdReadSocketSet.fd_array[nIndex] = pfdSocketSet->fd_array[nIndex];
}

if (pfdSocketSet->fd_count > 0)
{
/*select操作会将可以进行接收数据操作的socket从fdReadSocketSet里面筛选出来*/
nOperateCount = select(NULL, &fdReadSocketSet, NULL, NULL, NULL);

if (nOperateCount == SOCKET_ERROR)
{
printf("select error,error code:%d !!!\n", WSAGetLastError());
continue;
}

/*将符合条件的Socket逐个取出进行recv操作*/
for (int i = 0; i < nOperateCount; ++i)
{
memset(szDataBuff, 0, sizeof(szDataBuff));
nRecvResult = recv(fdReadSocketSet.fd_array[i], szDataBuff, sizeof(szDataBuff), 0);

if (nRecvResult == 0)	 /*返回值为0默认是断开*/
{
printf("socket %d disconnect!!!\n", fdReadSocketSet.fd_array[i]);
FD_CLR(fdReadSocketSet.fd_array[i], pfdSocketSet);
}
else if(nRecvResult == SOCKET_ERROR)
{
printf("socket %d error code:%d !!!\n", fdReadSocketSet.fd_array[i], WSAGetLastError());
FD_CLR(fdReadSocketSet.fd_array[i], pfdSocketSet);
}
else
{
printf("Sock %d :Recv Data is:%s !!!\n", fdReadSocketSet.fd_array[i], szDataBuff);
}
}
}
}

return 0;
}

int SelectTest()
{
SOCKET sockSrv = ServerSockInit();

if (sockSrv == SOCKET_ERROR)
{
printf("Create Server Socket Error!!!\n");

return -1;
}

/*保存sock的数组*/
fd_set	fdSocketSet;
FD_ZERO(&fdSocketSet);

/*创建辅助线程处理网络事件 */
HANDLE hProcessIO = CreateThread(NULL, 0, SelectProcessIO, &fdSocketSet, 0, NULL);

if(hProcessIO)
{
CloseHandle(hProcessIO);
}

SOCKET sockClient;
SOCKADDR_IN SockAddress;
in_addr inaddr;
INT nAddressLength = sizeof(SockAddress);

while (TRUE)
{
sockClient=accept(sockSrv, (sockaddr*)&SockAddress, &nAddressLength);

inaddr.s_addr=SockAddress.sin_addr.s_addr;

printf("Socket Register, IP:%s, Port:%d \n",
inet_ntoa(inaddr),
SockAddress.sin_port);

FD_SET(sockClient, &fdSocketSet);			/*将sockClient添加到数组里*/
}
}

#endif

二：WSAAsyncSelect模型

        这种模型下，负责人首先召集各个码头的调度人员，告诉他们：如果有货品要上岸，打电话给我啊，我电话是888 。好吧，于是有货的话，大家都忙着给负责人打电话，然后负责人接到电话后立刻赶往相应码头 处理货物，货品上岸，装集装箱，后面还有一大堆事情。好吧，要是忙碌的时候，可能负责人的电话各种占线，好吧，效率还是低，不过总比逐个码头跑好点。

注 ： 由于WSAAsyncSelect采用与MFC相同的句柄--消息机制实现，原理是跟点击按钮触发消息，处理消息一样，由于要用到Mfc程序，这里不举例子！！

三：WSAEventSelect模型



        好吧，负责人疲于奔命，所有他决定升级码头的系统，在信息中心为每个码头安装一个信号灯，负责人只要在信息中心看到哪些等亮起就知道有货要上岸了, 不过资金有限，只能安装64个信号灯，好吧，现在他可以雇多几个手下(线程)，告诉他们灯亮起的时候应该怎么做。好吧，效率终于提高点了。

#ifndef _WSAEVENTSELECT_
#define _WSAEVENTSELECT_

#include "StdAfx.h"

/*事件模式相关结构,保存socket以及对应的信号对象数组*/
typedef struct
{
int nEventCount;
WSAEVENT hEvents[WSA_MAXIMUM_WAIT_EVENTS];
SOCKET	 sockSet[WSA_MAXIMUM_WAIT_EVENTS];
}EventSet;

void EVENT_CLR(EventSet* pEventSet, WSAEVENT hEvent)
{
for (int i = 0; i < pEventSet->nEventCount; ++i)
{
if (pEventSet->hEvents[i] == hEvent)
{
while (i < pEventSet->nEventCount - 1)
{
pEventSet->hEvents[i] = pEventSet->hEvents[i+1];
pEventSet->sockSet[i] = pEventSet->sockSet[i+1];
++i;
}
pEventSet->nEventCount -- ;
break;
}
}
}

void EVENT_ADD(EventSet* pEventSet, WSAEVENT hEvent, SOCKET sock)
{
if (pEventSet->nEventCount == WSA_MAXIMUM_WAIT_EVENTS)
{
return;
}

pEventSet->hEvents[pEventSet->nEventCount] = hEvent;

pEventSet->sockSet[pEventSet->nEventCount] = sock;

pEventSet->nEventCount ++ ;
}

DWORD WINAPI WSAEventSelectProcessIO(LPVOID lpParam)
{
EventSet* pEventSet = (EventSet*)lpParam;

int dwWaitResult = 0;
int nEventIndex = 0;
WSANETWORKEVENTS WSANetworkEvents;
char szDataBuff[DATA_BUFFER_SIZE];
int nErrorCode = 0;

while(true)
{
dwWaitResult = WSAWaitForMultipleEvents(pEventSet->nEventCount, pEventSet->hEvents, FALSE, WSA_INFINITE, FALSE);

if (dwWaitResult == WSA_WAIT_FAILED)
{
/*信号量数组为null*/
nErrorCode = WSAGetLastError();

if (nErrorCode == WSA_INVALID_PARAMETER)
{
continue;
}

else
{
printf("WSAWaitForMultipleEvent error，error code :%d !!!", WSAGetLastError());
}

break;;
}

/*获取有信号的信号对象在数组中的下标未知*/
nEventIndex = dwWaitResult - WSA_WAIT_EVENT_0;

/*根据信号量和Socket获取网络事件*/
WSAEnumNetworkEvents(pEventSet->sockSet[nEventIndex],
pEventSet->hEvents[nEventIndex],
&WSANetworkEvents);

/*根据网络事件执行对应的操作*/
if (FD_READ == WSANetworkEvents.lNetworkEvents)
{
memset(szDataBuff, 0, sizeof(szDataBuff));
recv(pEventSet->sockSet[nEventIndex], szDataBuff, sizeof(szDataBuff), 0);
printf("Sock %d Recv Data:%s !!!\n", pEventSet->sockSet[nEventIndex], szDataBuff);
}
else
{
printf("lNetWorkEventCode is %d", WSANetworkEvents.lNetworkEvents);
}

WSAResetEvent(pEventSet->hEvents[nEventIndex]);	/*信号量重置*/
}

return 0;
}

INT WSAEventSelectTest()
{
SOCKET sockSrv = ServerSockInit();

if (sockSrv == SOCKET_ERROR)
{
printf("创建服务器端口出错!!!\n");

return -1;
}

/*信号数组*/
EventSet eventSet;
memset(&eventSet, 0, sizeof(eventSet));

/*创建完成端口处理完成消息线程 理论创建线程数 = cpu核心数+1 */
HANDLE hProcessIO = CreateThread(NULL, 0, WSAEventSelectProcessIO, &eventSet, 0, NULL);
if(hProcessIO)
{
CloseHandle(hProcessIO);
}

SOCKET sockClient;
SOCKADDR_IN SockAddress;
in_addr inaddr;
INT nAddressLength = sizeof(SockAddress);

while (TRUE)
{
sockClient=accept(sockSrv, (sockaddr*)&SockAddress, &nAddressLength);
inaddr.s_addr=SockAddress.sin_addr.s_addr;

WSAEVENT hTempEvent = WSACreateEvent();						/*创建新信号量*/
WSAEventSelect(sockClient, hTempEvent, FD_READ|FD_CLOSE);	/*绑定信号量与相关的网络事件*/
EVENT_ADD(&eventSet, hTempEvent, sockClient);				/*加到信号量数组里面*/

printf("收到SOCK注册, IP:%s, 端口:%d \n", inet_ntoa(inaddr), SockAddress.sin_port);
}

return 0;
}

#endif

四：OverLapped I/O 模型



        负责人厌恶了货物上岸，装集装箱的操作，它决定将这些事情交给码头调度员。 每个码头上放一个空的集装箱(重叠)，有货物要上岸的时候，码头调度员直接给其上岸，然后将其装好集装箱。然后再通过信号灯通知负责人，负责人再安排手下去干剩下的工作，干完了再把空集装箱放码头上，通过充分利用码头调度员的资源，现在效率更高了。

#ifndef _OVERLAPPEDIO_
#define _OVERLAPPEDIO_

#include "DataBase.h"

typedef struct
{
int							nSetCount;
WSAEVENT					hEvents[WSA_MAXIMUM_WAIT_EVENTS];
LPPER_HANDLE_DATA			pHandleDatas[WSA_MAXIMUM_WAIT_EVENTS];
LPPER_IO_OPERATION_DATA		pOperationsDatas[WSA_MAXIMUM_WAIT_EVENTS];
}OverLappedIoSet;

void OVERLAPPEDIOSET_CLR(OverLappedIoSet* pOverLappedIoSet, WSAEVENT hEvent)
{
for (int i = 0; i < pOverLappedIoSet->nSetCount; ++i)
{
if (pOverLappedIoSet->hEvents[i] == hEvent)
{
while (i < pOverLappedIoSet->nSetCount - 1)
{
pOverLappedIoSet->hEvents[i] = pOverLappedIoSet->hEvents[i+1];
pOverLappedIoSet->pOperationsDatas[i] = pOverLappedIoSet->pOperationsDatas[i+1];
pOverLappedIoSet->pHandleDatas[i] = pOverLappedIoSet->pHandleDatas[i+1];
++i;
}
pOverLappedIoSet->nSetCount -- ;
break;
}
}
}

void OVERLAPPEDIOSET_ADD(OverLappedIoSet* pOverLappedIoSet,
WSAEVENT hEvent,
LPPER_IO_OPERATION_DATA pOperationsData,
LPPER_HANDLE_DATA	pHandleData
)
{
if (pOverLappedIoSet->nSetCount == WSA_MAXIMUM_WAIT_EVENTS)
{
return;
}

pOverLappedIoSet->hEvents[pOverLappedIoSet->nSetCount] = hEvent;
pOverLappedIoSet->pOperationsDatas[pOverLappedIoSet->nSetCount] = pOperationsData;
pOverLappedIoSet->pHandleDatas[pOverLappedIoSet->nSetCount] = pHandleData;
pOverLappedIoSet->nSetCount ++ ;
}

DWORD WINAPI OverLapperdIoProcessIO(LPVOID lpParam)
{
OverLappedIoSet* pOverLappedIoSet = (OverLappedIoSet*)lpParam;

LPPER_IO_OPERATION_DATA pIoData = NULL;
LPPER_HANDLE_DATA pHandle = NULL;

DWORD dwWaitResult = 0;
int nEventIndex = 0;
int nBufferTransfered = 0;
int nFlag = 0;
int nErrorCode = 0;

while(true)
{
dwWaitResult = WSAWaitForMultipleEvents(pOverLappedIoSet->nSetCount, pOverLappedIoSet->hEvents, FALSE, WSA_INFINITE, FALSE);

if (dwWaitResult == WSA_WAIT_FAILED)
{
/*信号量数组为null*/
nErrorCode = WSAGetLastError();

if (nErrorCode == WSA_INVALID_PARAMETER)
{
continue;
}

else
{
printf("WSAWaitForMultipleEvent error，error code %d !!!", WSAGetLastError());
}

break;;
}

/*获取有信号的信号对象在数组中的下标未知*/
nEventIndex = dwWaitResult - WSA_WAIT_EVENT_0;
pIoData = pOverLappedIoSet->pOperationsDatas[nEventIndex];
pHandle = pOverLappedIoSet->pHandleDatas[nEventIndex];
printf("Sock %d :接收到数据:%s !!!\n", pHandle->Socket, pIoData->Buff);

memset(pIoData->Buff, 0, sizeof(pIoData->Buff));

int nRet = WSARecv(pHandle->Socket,
&(pIoData->DataBuff),
1,
(LPDWORD)&nBufferTransfered,
(LPDWORD)&nFlag,
(LPWSAOVERLAPPED)&pIoData->Overlapped,
NULL);

if (nRet != 0)
{
if ( (nErrorCode =WSAGetLastError()) != WSA_IO_PENDING )
{
printf("WSARecv error, error code: %d!!!", nErrorCode);
break;
}
}

WSAResetEvent(pOverLappedIoSet->hEvents[nEventIndex]);	/*信号量重置*/
}

return 0;
}

int OverLapperdIoTest()
{
SOCKET sockSrv = ServerSockInit();

if (sockSrv == SOCKET_ERROR)
{
printf("Create Server Socket Error!!!\n");

return -1;
}

/*信号数组*/
OverLappedIoSet overLappedIoSet;
memset(&overLappedIoSet, 0, sizeof(overLappedIoSet));
overLappedIoSet.nSetCount = 0;

/*创建辅助线程检测事件处理消息 */
HANDLE hProcessIO = CreateThread(NULL, 0, OverLapperdIoProcessIO, &overLappedIoSet, 0, NULL);
if(hProcessIO)
{
CloseHandle(hProcessIO);
}

SOCKET sockClient;
SOCKADDR_IN SockAddress;
in_addr inaddr;
INT nAddressLength = sizeof(SockAddress);

while (TRUE)
{
sockClient=accept(sockSrv, (sockaddr*)&SockAddress, &nAddressLength);
inaddr.s_addr=SockAddress.sin_addr.s_addr;

printf("Socket Register, IP:%s, Port:%d \n", inet_ntoa(inaddr), SockAddress.sin_port);

/*建立重叠数据*/
LPPER_IO_OPERATION_DATA pIoData = new PER_IO_OPERATION_DATA;
LPPER_HANDLE_DATA pHandle = new PER_HANDLE_DATA;

WSAEVENT hTempEvent = WSACreateEvent();	/*创建新信号量*/

memset(pIoData, 0, sizeof(PER_IO_OPERATION_DATA));
pIoData->DataBuff.len = sizeof(pIoData->Buff);
pIoData->DataBuff.buf = pIoData->Buff;
pIoData->Overlapped.hEvent = hTempEvent;
pHandle->Socket = sockClient;

int nBufferTransfered;
int nFlag = 0;
OVERLAPPEDIOSET_ADD(&overLappedIoSet, hTempEvent, pIoData, pHandle);		/*加到信号量数组里面*/

int nRet = WSARecv(sockClient, &(pIoData->DataBuff), 1, (LPDWORD)&nBufferTransfered,
(LPDWORD)&nFlag, (LPWSAOVERLAPPED)&pIoData->Overlapped, NULL);

if (nRet != 0)
{
int nErrorCode = WSAGetLastError();

if (nErrorCode != WSA_IO_PENDING )
{
printf("WSARecv error, error code: %d!!!", nErrorCode);
break;
}
}
}

return 0;
}

#endif

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



        负责人发现，只有人家干得多点，自己才能轻松快活点。所以他在刚才的基础上，写了个操作指引，让手下看到信号灯亮的时候能够按照指引去干活，自己就更省事了，不过遇到突发事件，可能操作指引不太适用哦。

#ifndef _IOCPRoutine_
#define _IOCPRoutine_

void CALLBACK CompletionROUTINE(
IN DWORD dwError,
IN DWORD cbTransferred,
IN LPWSAOVERLAPPED lpOverlapped,
IN DWORD dwFlags
)
{
LPPER_IO_OPERATION_DATA pIoData = (LPPER_IO_OPERATION_DATA)lpOverlapped;

if (cbTransferred == 0)
{
printf("Sock %d disconnect !!!\n", pIoData->Socket);
return;
}

printf("Sock %d: Recv Data:%s !!!\n", pIoData->Socket, pIoData->Buff);

/*继续投递*/
int nBufferTransfered	= 0;
int nFlag				= 0;

memset(pIoData->Buff, 0, sizeof(pIoData->Buff));

int nRet = WSARecv(	pIoData->Socket,
&(pIoData->DataBuff),
1,
(LPDWORD)&nBufferTransfered,
(LPDWORD)&nFlag,
(LPWSAOVERLAPPED)&pIoData->Overlapped,
CompletionROUTINE
);

if (nRet != 0)
{
int nErrorCode = WSAGetLastError();
if (nErrorCode != WSA_IO_PENDING )
{
printf("WSARecv error, error code: %d!!!");
}
}
}

int IOCPRoutine()
{
SOCKET sockSrv = ServerSockInit();

if (sockSrv == SOCKET_ERROR)
{
printf("Create Server Socket Error!!!\n");

return -1;
}

SOCKET sockClient;
SOCKADDR_IN SockAddress;
in_addr inaddr;
INT nAddressLength		= sizeof(SockAddress);
int nBufferTransfered	= 0;
int nFlag				= 0;

printf("Current Thread ID :%d !!!\n", GetCurrentThreadId());

while (TRUE)
{
sockClient=accept(sockSrv, (sockaddr*)&SockAddress, &nAddressLength);
inaddr.s_addr=SockAddress.sin_addr.s_addr;

printf("Socket Register, IP:%s, Port:%d \n", inet_ntoa(inaddr), SockAddress.sin_port);

/*建立重叠数据*/
LPPER_IO_OPERATION_DATA pIoData = new PER_IO_OPERATION_DATA;

memset(pIoData, 0, sizeof(PER_IO_OPERATION_DATA));
pIoData->DataBuff.len = sizeof(pIoData->Buff);
pIoData->DataBuff.buf = pIoData->Buff;
pIoData->Socket = sockClient;

int nRet = WSARecv(	sockClient,
&(pIoData->DataBuff),
1,
(LPDWORD)&nBufferTransfered,
(LPDWORD)&nFlag,
(LPWSAOVERLAPPED)&pIoData->Overlapped,
CompletionROUTINE
);

if (nRet != 0)
{
int nErrorCode = WSAGetLastError();
if (nErrorCode != WSA_IO_PENDING )
{
printf("WSARecv error, error code: %d!!!", nErrorCode);
break;
}
}
}
return 0;
}

#endif

六：完成端口 IOCP模型



        好吧，效率提高了，码头的规模也准备扩大了，由之前的64个码头，扩充到几百个，好吧，信号灯不适用了。再说，码头多的话就会很乱。于是负责人决定实施规模化管理，采购了N台(N个线程)大型的自动机器，这几天自动机器的本领可大了，它负责几百个码头的活，无论哪个码头有货来，它就负责货品上岸，装集装箱，然后将货品拉到对应的地点，所以说，负责人只要到对应的地点收货，处理剩下的就行了，其他的都不用忧，好吧，这机器人真牛X.

#ifndef _IOCP_
#define _IOCP_
#include "StdAfx.h"
#include "DataBase.h"

DWORD WINAPI ProcessIO(LPVOID lpParam)
{
HANDLE CompletionPort = (HANDLE)lpParam;
DWORD BytesTransferred;
LPPER_HANDLE_DATA PerHandleData;
LPPER_IO_OPERATION_DATA PerIoData;
printf("entering process");
while(true)
{
if(0 == GetQueuedCompletionStatus(CompletionPort, &BytesTransferred, (LPDWORD)&PerHandleData, (LPOVERLAPPED*)&PerIoData, INFINITE))
{
if( (GetLastError() ==WAIT_TIMEOUT) || (GetLastError() == ERROR_NETNAME_DELETED) )
{
closesocket(PerHandleData->Socket);
delete PerIoData;
delete PerHandleData;
continue;
}
else
{
printf("GetQueuedCompletionStatus failed!");
}
return 0;
}

/* 说明客户端已经退出 */
if(BytesTransferred == 0)
{
printf("Socket %d disconnect !!!\n", PerHandleData->Socket, PerIoData->Buff);
closesocket(PerHandleData->Socket);
delete PerIoData;
delete PerHandleData;
continue;
}

/*取得数据并处理*/
printf("Socket %d, Recv Data :%s \n", PerHandleData->Socket, PerIoData->Buff);

/*继续向 socket 投递WSARecv操作 */
DWORD Flags = 0;
DWORD dwRecv = 0;
ZeroMemory(PerIoData,sizeof(PER_IO_OPERATION_DATA));
PerIoData->DataBuff.buf =PerIoData->Buff;
PerIoData->DataBuff.len = DATA_BUFFER_SIZE;
WSARecv(PerHandleData->Socket,&PerIoData->DataBuff, 1, &dwRecv, &Flags,&PerIoData->Overlapped, NULL);
}
return 0;
}

INT IOCPTest()
{
SOCKET sockSrv = ServerSockInit();

/*创建完成端口句柄*/
HANDLE hIocp=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0);

/*创建完成端口处理完成消息线程 理论创建线程数 = cpu核心数+1 */
HANDLE hProcessIO = CreateThread(NULL, 0,ProcessIO, hIocp, 0, NULL);
if(hProcessIO)
{
CloseHandle(hProcessIO);
}

SOCKET sockClient;
SOCKADDR_IN SockAddress;
in_addr inaddr;
INT nAddressLength = sizeof(SockAddress);

while (TRUE)
{
sockClient=accept(sockSrv, (sockaddr*)&SockAddress, &nAddressLength);
inaddr.s_addr=SockAddress.sin_addr.s_addr;

printf("SOCK register, IP:%s, Port:%d \n", inet_ntoa(inaddr), SockAddress.sin_port);

/*重叠IO标识结构和数据结构*/
LPPER_HANDLE_DATA perHandleData=new PER_HANDLE_DATA;
LPPER_IO_OPERATION_DATA perIoData=new PER_IO_OPERATION_DATA;
ZeroMemory(perIoData,sizeof(PER_IO_OPERATION_DATA));
perHandleData->Socket = sockClient;
perIoData->DataBuff.buf = perIoData->Buff;
perIoData->DataBuff.len = DATA_BUFFER_SIZE;

/*绑定到完成端口*/
CreateIoCompletionPort((HANDLE)sockClient,hIocp,(DWORD)perHandleData,0);

/*向完成端口投递sock接收请求操作*/
DWORD dwFlag=0;
DWORD dwRecSize=0;
WSARecv(sockClient, &perIoData->DataBuff, 1, &dwRecSize, &dwFlag, &perIoData->Overlapped, NULL);
}

return 0;
}

#endif

总结：

那么多网络模型，看得头都有点晕了，究竟哪个才是最好的，其实我觉得适合自己的才是最好的。

<1>假如你的软件只需要一个socket来通信，相信Recv,Send等阻塞函数都可以满足你的要求。

<2>若你要管理的socket可能有几个，那select是你的选择，相信遍历那几个不会耗费你很多资源。

<3>如果你在写客户端通信软件，而且用上mfc，那WSAAsyncSelect将会让让消息映射处理发挥得淋漓尽致。

<4>另外事件select 和 重叠IO 也是好东西，只不过事件数组有64的限制，真需要多的话那就躲开几个数组检测吧。

<5>完成端口例程貌似比前两个简单一点，无需再处理繁杂的事件信号，不过可定制差点，而且应该只能在发起操作的那个线程完成操作。

<6>假如你要做windows通信服务器的话，要管理庞大的socket连接的话，强烈建议完成端口IOCP，完善的线程池管理，加上重叠IO的结合，底层的高度优化,谁用谁知道好。

例子代码：http://download.csdn.net/detail/luoti784600/5705175