Windows Socket IO模型.docx
《Windows Socket IO模型.docx》由会员分享，可在线阅读，更多相关《Windows Socket IO模型.docx（14页珍藏版）》请在冰豆网上搜索。
WindowsSocketIO模型
WindowsSocketI/O模型---重叠I/O模型、完成端口模型
四.重叠I/O模型
Winsock2的发布使得SocketI/O有了和文件I/O统一的接口。
我们可以通过使用Win32文件操纵函数ReadFile和WriteFile来进行SocketI/O。
伴随而来的，用于普通文件I/O的重叠I/O模型和完成端口模型对SocketI/O也适用了。
这些模型的优点是可以达到更佳的系统性能，但是实现较为复杂，里面涉及较多的C语言技巧。
例如我们在完成端口模型中会经常用到所谓的“尾随数据”。
1.用事件通知方式实现的重叠I/O模型
#include
#include
#definePORT 5150
#defineMSGSIZE1024
#pragmacomment（lib,"ws2_32.lib"）
typedefstruct
{
WSAOVERLAPPEDoverlap;
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_DATAg_pPerIODataArr[MAXIMUM_WAIT_OBJECTS];
DWORDWINAPIWorkerThread（LPVOID）;
voidCleanup（int）;
intmain（）
{
WSADATA wsaData;
SOCKET sListen,sClient;
SOCKADDR_INlocal,client;
DWORD dwThreadId;
int iaddrSize=sizeof（SOCKADDR_IN）;
//InitializeWindowsSocketlibrary
WSAStartup（0x0202,&wsaData）;
//Createlisteningsocket
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,（structsockaddr*）&local,sizeof（SOCKADDR_IN））;
//Listen
listen（sListen,3）;
//Createworkerthread
CreateThread（NULL,0,WorkerThread,NULL,0,&dwThreadId）;
while（TRUE）
{
//Acceptaconnection
sClient=accept（sListen,（structsockaddr*）&client,&iaddrSize）;
printf（"Acceptedclient:
%s:
%d\n",inet_ntoa（client.sin_addr）,ntohs（client.sin_port））;
g_CliSocketArr[g_iTotalConn]=sClient;
//AllocateaPER_IO_OPERATION_DATAstructure
g_pPerIODataArr[g_iTotalConn]=（LPPER_IO_OPERATION_DATA）HeapAlloc（
GetProcessHeap（）,
HEAP_ZERO_MEMORY,
sizeof（PER_IO_OPERATION_DATA））;
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（）;
//Launchanasynchronousoperation
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（）;
return0;
}
DWORDWINAPIWorkerThread（LPVOIDlpParam）
{
int ret,index;
DWORDcbTransferred;
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）
{
//Theconnectionwasclosedbyclient
Cleanup（index）;
}
else
{
//g_pPerIODataArr[index]->szMessagecontainsthereceiveddata
g_pPerIODataArr[index]->szMessage[cbTransferred]='\0';
send（g_CliSocketArr[index],g_pPerIODataArr[index]->szMessage,\
cbTransferred,0）;
//Launchanotherasynchronousoperation
WSARecv（
g_CliSocketArr[index],
&g_pPerIODataArr[index]->Buffer,
1,
&g_pPerIODataArr[index]->NumberOfBytesRecvd,
&g_pPerIODataArr[index]->Flags,
&g_pPerIODataArr[index]->overlap,
NULL）;
}
}
return0;
}
voidCleanup（intindex）
{
closesocket（g_CliSocketArr[index]）;
WSACloseEvent（g_CliEventArr[index]）;
HeapFree（GetProcessHeap（）,0,g_pPerIODataArr[index]）;
if（index {
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;
}
这个模型与上述其他模型不同的是它使用Winsock2提供的异步I/O函数WSARecv。
在调用WSARecv时，指定一个WSAOVERLAPPED结构，这个调用不是阻塞的，也就是说，它会立刻返回。
一旦有数据到达的时候，被指定的WSAOVERLAPPED结构中的hEvent被Signaled。
由于下面这个语句
g_CliEventArr[g_iTotalConn]=g_pPerIODataArr[g_iTotalConn]->overlap.hEvent；
使得与该套接字相关联的WSAEVENT对象也被Signaled，所以WSAWaitForMultipleEvents的调用操作成功返回。
我们现在应该做的就是用与调用WSARecv相同的WSAOVERLAPPED结构为参数调用WSAGetOverlappedResult，从而得到本次I/O传送的字节数等相关信息。
在取得接收的数据后，把数据原封不动的发送到客户端，然后重新激活一个WSARecv异步操作。
2.用完成例程方式实现的重叠I/O模型
#include
#include
#definePORT 5150
#defineMSGSIZE1024
#pragmacomment（lib,"ws2_32.lib"）
typedefstruct
{
WSAOVERLAPPEDoverlap;
WSABUF Buffer;
char szMessage[MSGSIZE];
DWORD NumberOfBytesRecvd;
DWORD Flags;
SOCKET sClient;
}PER_IO_OPERATION_DATA,*LPPER_IO_OPERATION_DATA;
DWORDWINAPIWorkerThread（LPVOID）;
voidCALLBACKCompletionROUTINE（DWORD,DWORD,LPWSAOVERLAPPED,DWORD）;
SOCKETg_sNewClientConnection;
BOOL g_bNewConnectionArrived=FALSE;
intmain（）
{
WSADATA wsaData;
SOCKET sListen;
SOCKADDR_INlocal,client;
DWORD dwThreadId;
int iaddrSize=sizeof（SOCKADDR_IN）;
//InitializeWindowsSocketlibrary
WSAStartup（0x0202,&wsaData）;
//Createlisteningsocket
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,（structsockaddr*）&local,sizeof（SOCKADDR_IN））;
//Listen
listen（sListen,3）;
//Createworkerthread
CreateThread（NULL,0,WorkerThread,NULL,0,&dwThreadId）;
while（TRUE）
{
//Acceptaconnection
g_sNewClientConnection=accept（sListen,（structsockaddr*）&client,&iaddrSize）;
g_bNewConnectionArrived=TRUE;
printf（"Acceptedclient:
%s:
%d\n",inet_ntoa（client.sin_addr）,ntohs（client.sin_port））;
}
}
DWORDWINAPIWorkerThread（LPVOIDlpParam）
{
LPPER_IO_OPERATION_DATAlpPerIOData=NULL;
while（TRUE）
{
if（g_bNewConnectionArrived）
{
//Launchanasynchronousoperationfornewarrivedconnection
lpPerIOData=（LPPER_IO_OPERATION_DATA）HeapAlloc（
GetProcessHeap（）,
HEAP_ZERO_MEMORY,
sizeof（PER_IO_OPERATION_DATA））;
lpPerIOData->Buffer.len=MSGSIZE;
lpPerIOData->Buffer.buf=lpPerIOData->szMessage;
lpPerIOData->sClient=g_sNewClientConnection;
WSARecv（lpPerIOData->sClient,
&lpPerIOData->Buffer,
1,
&lpPerIOData->NumberOfBytesRecvd,
&lpPerIOData->Flags,
&lpPerIOData->overlap,
CompletionROUTINE）;
g_bNewConnectionArrived=FALSE;
}
SleepEx（1000,TRUE）;
}
return0;
}
voidCALLBACKCompletionROUTINE（DWORDdwError,
DWORDcbTransferred,
LPWSAOVERLAPPEDlpOverlapped,
DWORDdwFlags）
{
LPPER_IO_OPERATION_DATAlpPerIOData=（LPPER_IO_OPERATION_DATA）lpOverlapped;
if（dwError!
=0||cbTransferred==0）
{
//Connectionwasclosedbyclient
closesocket（lpPerIOData->sClient）;
HeapFree（GetProcessHeap（）,0,lpPerIOData）;
}
else
{
lpPerIOData->szMessage[cbTransferred]='\0';
send（lpPerIOData->sClient,lpPerIOData->szMessage,cbTransferred,0）;
//Launchanotherasynchronousoperation
memset（&lpPerIOData->overlap,0,sizeof（WSAOVERLAPPED））;
lpPerIOData->Buffer.len=MSGSIZE;
lpPerIOData->Buffer.buf=lpPerIOData->szMessage;
WSARecv（lpPerIOData->sClient,
&lpPerIOData->Buffer,
1,
&lpPerIOData->NumberOfBytesRecvd,
&lpPerIOData->Flags,
&lpPerIOData->overlap,
CompletionROUTINE）;
}
}
用完成例程来实现重叠I/O比用事件通知简单得多。
在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，就为那个客户端套接字激活一个异步的WSARecv操作，然后调用SleepEx使线程处于一种可警告的等待状态，以使得I/O完成后CompletionROUTINE可以被内核调用。
如果辅助线程不调用SleepEx，则内核在完成一次I/O操作后，无法调用完成例程（因为完成例程的运行应该和当初激活WSARecv异步操作的代码在同一个线程之内）。
完成例程内的实现代码比较简单，它取出接收到的数据，然后将数据原封不动的发送给客户端，最后重新激活另一个WSARecv异步操作。
注意，在这里用到了“尾随数据”。
我们在调用WSARecv的时候，参数lpOverlapped实际上指向一个比它大得多的结构PER_IO_OPERATION_DATA，这个结构除了WSAOVERLAPPED以外，还被我们附加了缓冲区的结构信息，另外还包括客户端套接字等重要的信息。
这样，在完成例程中通过参数lpOverlapped拿到的不仅仅是WSAOVERLAPPED结构，还有后边尾随的包含客户端套接字和接收数据缓冲区等重要信息。
这样的C语言技巧在我后面介绍完成端口的时候还会使用到。
五.完成端口模型
“完成端口”模型是迄今为止最为复杂的一种I/O模型。
然而，假若一个应用程序同时需要管理为数众多的套接字，那么采用这种模型，往往可以达到最佳的系统性能！
但不幸的是，该模型只适用于WindowsNT和Windows2000操作系统。
因其设计的复杂性，只有在你的应用程序需要同时管理数百乃至上千个套接字的时候，而且希望随着系统内安装的CPU数量的增多，应用程序的性能也可以线性提升，才应考虑采用“完成端口”模型。
要记住的一个基本准则是，假如要为WindowsNT或Windows2000开发高性能的服务器应用，同时希望为大量套接字I/O请求提供服务（Web服务器便是这方面的典型例子），那么I/O完成端口模型便是最佳选择！
（节选自《Windows网络编程》第八章）
完成端口模型是我最喜爱的一种模型。
虽然其实现比较复杂（其实我觉得它的实现比用事件通知实现的重叠I/O简单多了），但其效率是惊人的。
我在T公司的时候曾经帮同事写过一个邮件服务器的性能测试程序，用的就是完成端口模型。
结果表明，完成端口模型在多连接（成千上万）的情况下，仅仅依靠一两个辅助线程，就可以达到非常高的吞吐量。
下面我还是从代码说起：
#include
#include
#definePORT 5150
#defineMSGSIZE1024
#pragmacomment（lib,"ws2_32.lib"）
typedefenum
{
RECV_POSTED
}OPERATION_TYPE;
typedefstruct
{
WSAOVERLAPPED overlap;
WSABUF Buffer;
char szMessage[MSGSIZE];
DWORD NumberOfBytesRecvd;
DWORD Flags;
OPERATION_TYPEOperationType;
}PER_IO_OPERATION_DATA,*LPPER_IO_OPERATION_DATA;
DWORDWINAPIWorkerThread（LPVOID）;
intmain（）
{
WSADATA
升级会员 