客户端:创建套接字,连接服务器,然后不停的发送和接收数据。

比较容易想到的一种服务器模型就是采用一个主线程,负责监听客户端的连接请求,当接收到某个客户端的连接请求后,创建一个专门用于和该客户端通信的套接字和一个辅助线程。以后该客户端和服务器的交互都在这个辅助线程内完成。这种方法比较直观,程序非常简单而且可移植性好,但是不能利用平台相关的特性。例如,如果连接数增多的时候(成千上万的连接),那么线程数成倍增长,操作系统忙于频繁的线程间切换,而且大部分线程在其生命周期内都是处于非活动状态的,这大大浪费了系统的资源。所以,如果你已经知道你的代码只会运行在Windows平台上,建议采用Winsock I/O模型。

一.Select模型: 轮询fd_set集合

利用select函数,实现对I/O 的管理。最初设计该模型时,主要面向的是某些使用UNIX操作系统的计算机,它们采用的是Berkeley套接字方案。Select模型已集成到 Winsock 1.1中,它使那些想避免在套接字调用过程中被无辜“锁定”的应用程序,采取一种有序的方式,同时进行对多个套接字的管理。

int select(
int nfds,
fd_set* readfds,
fd_set* writefds,
fd_set* exceptfds,
const struct timeval* timeout
);

nfds:本参数忽略,仅起到兼容作用。
   readfds:(可选)指针,指向一组等待可读性检查的套接口。
   writefds:(可选)指针,指向一组等待可写性检查的套接口。
   exceptfds:(可选)指针,指向一组等待错误检查的套接口。
   timeout:select()最多等待时间,对阻塞操作则为NULL。

FD_CLR(s,*set):从集合set中删除描述字s。
   FD_ISSET(s,*set):若s为集合中一员,非零;否则为零。
   FD_SET(s,*set):向集合添加描述字s。
   FD_ZERO(*set):将set初始化为空集NULL。
   timeout参数控制select()完成的时间。若timeout参数为空指针,则select()将一直阻塞到有一个描述字满足条件。否则的话,timeout指向一个timeval结构,其中指定了select()调用在返回前等待多长时间。如果timeval为{0,0},则 select()立即返回,这可用于探询所选套接口的状态。

服务器来轮询查看某个套接字是否仍然处于读集中,如果是,则接收数据。如果接收的数据长度为0,或者发生WSAECONNRESET错误,则表示客户端套接字主动关闭,这时需要将服务器中对应的套接字所绑定的资源释放掉,然后调整我们的套接字数组(将数组中最后一个套接字挪到当前的位置上) 
除了需要有条件接受客户端的连接外,还需要在连接数为0的情形下做特殊处理,因为如果读集中没有任何套接字,select函数会立刻返回。

当调用非阻塞模式时,可以说socket在select上设置超时时间阻塞应用。
select 会在超时时间测试fd_set集合是否可用,如果超时/没有数据可读了会清除当前集合成员。

二.异步选择 
应用程序可以在一个套接字上接收以WINDOWS消息为基础的网络事件通知。该模型的实现方法是通过调用WSAAsynSelect函数 自动将套接字设置为非阻塞模式,并向WINDOWS注册一个或多个网络时间,并提供一个通知时使用的窗口句柄。当注册的事件发生时,对应的窗口将收到一个基于消息的通知。

三.事件选择 
Winsock 提供了另一个有用的异步I/O模型。和WSAAsyncSelect模型类似的是,它也允许应用程序在一个或多个套接字上,接收以事件为基础的网络事件通知。
基本思想是将每个套接字都和一个WSAEVENT对象对应起来,并且在关联的时候指定需要关注的哪些网络事件。一旦在某个套接字上发生了我们关注的事件(FD_READ和FD_CLOSE),与之相关联的WSAEVENT对象被Signaled。

四.重叠I/O模型

readfile或者writefile的调用马上就会返回,这时候你可以去做你要做的事,系统会自动替你完成readfile或者writefile,在你调用了readfile或者writefile后,你继续做你的事,系统同时也帮你完成readfile或writefile的操作,这就是所谓的重叠。

1.用事件通知方式实现的重叠I/O模型 
异步I/O函数WSARecv。在调用WSARecv时,指定一个 WSAOVERLAPPED结构,这个调用不是阻塞的,也就是说,它会立刻返回。一旦有数据到达的时候,被指定的WSAOVERLAPPED结构中的 hEvent被Signaled。使得与该套接字相关联的WSAEVENT对象也被Signaled,所以WSAWaitForMultipleEvents的调用操作成功返回。

2.用完成例程方式实现的重叠I/O模型

WSARecv时传递CompletionROUTINE指针,回调函数,当IO请求完成时调用该回调函数完成我们需要处理的工作,在这个模型中,主线程只用不停的接受连接即可;辅助线程判断有没有新的客户端连接被建立,如果有,就为那个客户端套接字激活一个异步的WSARecv操作,然后调用SleepEx使线程处于一种可警告的等待状态,以使得I/O完成后 CompletionROUTINE可以被内核调用。如果辅助线程不调用SleepEx,则内核在完成一次I/O操作后,无法调用完成例程(因为完成例程的运行应该和当初激活WSARecv异步操作的代码在同一个线程之内)。

Windows提供了四种异步IO技术,机制几乎是相同的,区别在于通知结果的方式不同:
1、使一个设备内核对象变为有信号
Windows将设备句柄看作可同步的对象,即它可以处于有信号或处于无信号状态,当创建设备句柄、以异步的方式发送IO请求时,该句柄处于无信号状态,当异步IO完成之后,该句柄受信,通过WaitForSingleobject或WatiForMultipleObjects函数可以判断设备操作合适完成。该技术只能用于一个设备只发送一个IO请求,否则,若一个设备对应多个操作,当句柄受信时无法判断是该设备的那个操作完成。
2、使一个事件内核对象变为有信号
针对每个I/O操作绑定一个内核事件对象,并将等待事件等待函数等待该事件的受信,当I/O操作完成后系统使得与该操作绑定的事件受信,从而判断那个操作完成。该技术解决了使一个设备内核对象变为有信号技术中一个设备只能对应一个操作的不足。
3、警告I/O
在该技术中,当发出设备IO请求时,同时要求我们传递一个被称为完成例程的回调函数,当IO请求完成时调用该回调函数完成我们需要处理的工作。该技术允许单个设备同时进行多个I/O请求。
4、完成端口
完成端口技术多用于处理大规模的请求,通过内在的进程池技术可以达到很高的性能。
-

五.完成端口模型 
只有在你的应用程序需要同时管理数百乃至上千个套接字的时候,而且希望随着系统内安装的CPU数量的增多,应用程序的性能也可以线性提升,才应考虑采用“完成端口”模型。

完成端口内部提供了线程池的管理,可以避免反复创建线程的开销,同时可以根据CPU的个数灵活的决定线程个数,而且可以让减少线程调度的次数从而提高性能。
首先要创建一个 I / O完成端口对象

HANDLE CreateIoCompletionPort (

HANDLE FileHandle,              // handle to file

HANDLE ExistingCompletionPort,  // handle to I/O completion port

ULONG_PTR CompletionKey,        // completion key

DWORD NumberOfConcurrentThreads // number of threads to execute concurrently

);
我们深入探讨其中的各个参数之前,首先要注意该函数实际用于两个明显有别的目的:
■ 用于创建一个完成端口对象。
■ 将一个句柄同完成端口关联到一起。
最开始创建一个完成端口时,唯一感兴趣的参数便是 NumberOfConcurrentThreads(并发
线程的数量);前面三个参数都会被忽略。NumberOfConcurrentThreads参数的特殊之处在于,它定义了在一个完成端口上,同时允许执行的线程数量。理想情况下,我们希望每个处理器各自负责一个线程的运行,为完成端口提供服务,避免过于频繁的线程“场景”切换。若将该参数设为0,表明系统内安装了多少个处理器,便允许同时运行多少个线程!可用下述代码创建一个I / O完成端口:

CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0)

该语句的作用是返回一个句柄,在为完成端口分配了一个套接字句柄后,用来对那个端
口进行标定(引用)。

工作者线程调用 GetQueuedCompletionStatus 来轮询完成端口队列

 

如果你想在Windows平台上构建服务器应用,那么I/O模型是你必须考虑的。Windows操作系统提供了
选择(Select)、异步选择(WSAAsyncSelect)、事件选择(WSAEventSelect)、重叠I/O(Overlapped I/O)和完成端口(Completion Port)
共五种I/O模型。每一种模型均适用于一种特定的应用场景。程序员应该对自己的应用需求非常明确,而且综合考虑到程序的扩展性和可移植性
等因素,作出自己的选择。
    我会以一个回应反射式服务器(与《Windows网络编程》第八章一样)来介绍这五种I/O模型。 
我们假设客户端的代码如下(为代码直观,省去所有错误检查,以下同):
#include <WINSOCK2.H>
#include <stdio.h>
#define SERVER_ADDRESS "137.117.2.148"
#define PORT           5150
#define MSGSIZE        1024
#pragma comment(lib, "ws2_32.lib")
int main()
{
WSADATA     wsaData;
SOCKET      sClient;
SOCKADDR_IN server;
char        szMessage[MSGSIZE];
int         ret;

// Initialize Windows socket library
WSAStartup(0x0202, &wsaData);
// Create client socket
sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
// Connect to server
memset(&server, 0, sizeof(SOCKADDR_IN));
server.sin_family = AF_INET;
server.sin_addr.S_un.S_addr = inet_addr(SERVER_ADDRESS);
server.sin_port = htons(PORT);
connect(sClient, (struct sockaddr *)&server, sizeof(SOCKADDR_IN));
while (TRUE)
{
    printf("Send:");
gets(szMessage);
    // Send message
    send(sClient, szMessage, strlen(szMessage), 0);
    // Receive message
    ret = recv(sClient, szMessage, MSGSIZE, 0);
    szMessage[ret] = '\0';
    printf("Received [%d bytes]: '%s'\n", ret, szMessage);
}
// Clean up
closesocket(sClient);
WSACleanup();
return 0;
}

客户端所做的事情相当简单,创建套接字,连接服务器,然后不停的发送和接收数据。
    比较容易想到的一种服务器模型就是采用一个主线程,负责监听客户端的连接请求,当接收到某个客户端的连接请求后,创建一个专门
用于和该客户端通信的套接字和一个辅助线程。以后该客户端和服务器的交互都在这个辅助线程内完成。这种方法比较直观,程序非常简单
而且可移植性好,但是不能利用平台相关的特性。例如,如果连接数增多的时候(成千上万的连接),那么线程数成倍增长,操作系统忙于
频繁的线程间切换,而且大部分线程在其生命周期内都是处于非活动状态的,这大大浪费了系统的资源。所以,如果你已经知道你的代码只
会运行在Windows平台上,建议采用Winsock I/O模型。

一.选择模型

Select(选择)模型是Winsock中最常见的I/O模型。之所以称其为“Select模型”,是由于它的“中心思想”便是利用select函数,实现对
I/O的管理。最初设计该模型时,主要面向的是某些使用UNIX操作系统的计算机,它们采用的是Berkeley套接字方案。Select模型已集成到
Winsock 1.1中,它使那些想避免在套接字调用过程中被无辜“锁定”的应用程序,采取一种有序的方式,同时进行对多个套接字的管理。由
于Winsock 1.1向后兼容于Berkeley套接字实施方案,所以假如有一个Berkeley套接字应用使用了select函数,那么从理论角度讲,毋需对
其进行任何修改,便可正常运行。(节选自《Windows网络编程》第八章)

下面的这段程序就是利用选择模型实现的Echo服务器的代码(已经不能再精简了):
#include <winsock.h>
#include <stdio.h>
#define PORT       5150
#define MSGSIZE    1024
#pragma comment(lib, "ws2_32.lib")
int    g_iTotalConn = 0;
SOCKET g_CliSocketArr[FD_SETSIZE];
DWORD WINAPI WorkerThread(LPVOID lpParameter);
int main()
{
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_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));
// Listen
listen(sListen, 3);
// Create worker thread
CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); 
while (TRUE)
{
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    // Add socket to g_CliSocketArr
    g_CliSocketArr[g_iTotalConn++] = sClient;
}

return 0;
}
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
int            i;
fd_set         fdread;
int            ret;
struct timeval tv = {1, 0};
char           szMessage[MSGSIZE];

while (TRUE)
{
    FD_ZERO(&fdread);
    for (i = 0; i < g_iTotalConn; i++)
    {
      FD_SET(g_CliSocketArr[i], &fdread);
    }
    // We only care read event
    ret = select(0, &fdread, NULL, NULL, &tv);
    if (ret == 0)
    {
      // Time expired
      continue;
    }
    for (i = 0; i < g_iTotalConn; i++)
    {
      if (FD_ISSET(g_CliSocketArr[i], &fdread))
      {
        // A read event happened on g_CliSocketArr[i]
        ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
    {
     // Client socket closed
          printf("Client socket %d closed.\n", g_CliSocketArr[i]);
     closesocket(g_CliSocketArr[i]);
     if (i < g_iTotalConn - 1)
          {            
            g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn];
          }
        }
    else
    {
     // We received a message from client
          szMessage[ret] = '\0';
     send(g_CliSocketArr[i], szMessage, strlen(szMessage), 0);
        }
      }
    }
}

return 0;
}
服务器的几个主要动作如下:
1.创建监听套接字,绑定,监听;
2.创建工作者线程;
3.创建一个套接字数组,用来存放当前所有活动的客户端套接字,每accept一个连接就更新一次数组;
4.接受客户端的连接。这里有一点需要注意的,就是我没有重新定义FD_SETSIZE宏,所以服务器最多支持的并发连接数为64。而且,这里决不
能无条件的accept,服务器应该根据当前的连接数来决定是否接受来自某个客户端的连接。一种比较好的实现方案就是采用WSAAccept函数,而
且让WSAAccept回调自己实现的Condition Function。如下所示:

int CALLBACK ConditionFunc(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData)
{
if (当前连接数 < FD_SETSIZE)
return CF_ACCEPT;
else
return CF_REJECT;
}

工作者线程里面是一个死循环,一次循环完成的动作是:
1.将当前所有的客户端套接字加入到读集fdread中;
2.调用select函数;
3.查看某个套接字是否仍然处于读集中,如果是,则接收数据。如果接收的数据长度为0,或者发生WSAECONNRESET错误,则表示客户端套接字主
动关闭,这时需要将服务器中对应的套接字所绑定的资源释放掉,然后调整我们的套接字数组(将数组中最后一个套接字挪到当前的位置上)
除了需要有条件接受客户端的连接外,还需要在连接数为0的情形下做特殊处理,因为如果读集中没有任何套接字,select函数会立刻返回,这
将导致工作者线程成为一个毫无停顿的死循环,CPU的占用率马上达到100%。

二.异步选择

Winsock提供了一个有用的异步I/O模型。利用这个模型,应用程序可在一个套接字上,接收以Windows
(这篇文章是本人转载的,但我不认为WSAAsyncSelect属于AIO,因为IO操作还是你自己做了,操作系统只是用了消息通知你而已)
消息为基础的网络事件通知。具体的做法是在建好一个套接字后,调用WSAAsyncSelect函数。该模型最早出现于Winsock的1.1版本中,用于帮助应用程序开发者面向一些早期的16位Windows平台(如Windows for Workgroups),适应其“落后”的多任务消息环境。应用程序仍可从这种模型中得到好处,特别是它们用一个标准的Windows例程(常称为"WndProc"),对窗口消息进行管理的时候。该模型亦得到了Microsoft Foundation Class(微软基本类,MFC)对象CSocket的采纳。(节选自《Windows网络编程》第八章)

我还是先贴出代码,然后做详细解释:

#include <winsock.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是最简单的一种Winsock I/O模型(之所以说它简单是因为一个主线程就搞定了)。使用Raw Windows API写
过窗口类应用程序的人应该都能看得懂。这里,我们需要做的仅仅是:

1.在WM_CREATE消息处理函数中,初始化Windows Socket library,创建监听套接字,绑定,监听,并且调用WSAAsyncSelect函数表示我们
关心在监听套接字上发生的FD_ACCEPT事件;
2.自定义一个消息WM_SOCKET,一旦在我们所关心的套接字(监听套接字和客户端套接字)上发生了某个事件,系统就会调用WndProc并且
message参数被设置为WM_SOCKET;
3.在WM_SOCKET的消息处理函数中,分别对FD_ACCEPT、FD_READ和FD_CLOSE事件进行处理;
4.在窗口销毁消息(WM_DESTROY)的处理函数中,我们关闭监听套接字,清除Windows Socket library

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

表1
FD_READ 应用程序想要接收有关是否可读的通知,以便读入数据 
FD_WRITE 应用程序想要接收有关是否可写的通知,以便写入数据 
FD_OOB 应用程序想接收是否有带外(OOB)数据抵达的通知 
FD_ACCEPT 应用程序想接收与进入连接有关的通知 
FD_CONNECT 应用程序想接收与一次连接或者多点join操作完成的通知 
FD_CLOSE 应用程序想接收与套接字关闭有关的通知 
FD_QOS 应用程序想接收套接字“服务质量”(QoS)发生更改的通知 
FD_GROUP_QOS 应用程序想接收套接字组“服务质量”发生更改的通知(现在没什么用处,为未来套接字组的使用保留) 
FD_ROUTING_INTERFACE_CHANGE 应用程序想接收在指定的方向上,与路由接口发生变化的通知 
FD_ADDRESS_LIST_CHANGE 应用程序想接收针对套接字的协议家族,本地地址列表发生变化的通知

三.事件选择

Winsock提供了另一个有用的异步I/O模型。和WSAAsyncSelect模型类似的是,它也允许应用程序在一个
(这篇文章是本人转载的,但我不认为WSAEventSelect属于AIO,因为IO操作还是你自己做了,操作系统只是用了事件通知你而已)
或多个套接字上,接收以事件为基础的网络事件通知。对于表1总结的、由WSAAsyncSelect模型采用的网络事件来说,它们均可原封不动地移植到新模型。在用新模型开发的应用程序中,也能接收和处理所有那些事件。该模型最主要的差别在于网络事件会投递至一个事件对象句柄,而非投递至一个窗口例程。
(节选自《Windows网络编程》第八章)

还是让我们先看代码然后进行分析:

#include <winsock2.h>
#include <stdio.h>
#define PORT    5150
#define MSGSIZE 1024
#pragma comment(lib, "ws2_32.lib")
int      g_iTotalConn = 0;
SOCKET   g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
DWORD WINAPI WorkerThread(LPVOID);
void Cleanup(int index);
int main()
{
WSADATA     wsaData;
SOCKET      sListen, sClient;
SOCKADDR_IN local, client;
DWORD       dwThreadId;
int         iaddrSize = sizeof(SOCKADDR_IN);
// Initialize Windows Socket library
WSAStartup(0x0202, &wsaData);
// 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(SOCKADDR_IN));
// Listen
listen(sListen, 3);
// Create worker thread
CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
while (TRUE)
{
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    // Associate socket with network event
    g_CliSocketArr[g_iTotalConn] = sClient;
    g_CliEventArr[g_iTotalConn] = WSACreateEvent();
    WSAEventSelect(g_CliSocketArr[g_iTotalConn],
                   g_CliEventArr[g_iTotalConn],
                   FD_READ | FD_CLOSE);
    g_iTotalConn++;
}
}
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
int              ret, index;
WSANETWORKEVENTS NetworkEvents;
char             szMessage[MSGSIZE];
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;
    WSAEnumNetworkEvents(g_CliSocketArr[index], g_CliEventArr[index], &NetworkEvents);
    if (NetworkEvents.lNetworkEvents & FD_READ)
    {
      // Receive message from client
      ret = recv(g_CliSocketArr[index], szMessage, MSGSIZE, 0);
      if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
      {
        Cleanup(index);
      }
      else
      {
        szMessage[ret] = '\0';
        send(g_CliSocketArr[index], szMessage, strlen(szMessage), 0);
      }
    }
    if (NetworkEvents.lNetworkEvents & FD_CLOSE)
{
   Cleanup(index);
}
}
return 0;
}
void Cleanup(int index)
{
closesocket(g_CliSocketArr[index]);
WSACloseEvent(g_CliEventArr[index]);
if (index < g_iTotalConn - 1)
{
g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];
g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];
}

g_iTotalConn--;
}

事件选择模型也比较简单,实现起来也不是太复杂,它的基本思想是将每个套接字都和一个WSAEVENT对象对应起来,并且在关联的时候
指定需要关注的哪些网络事件。一旦在某个套接字上发生了我们关注的事件(FD_READ和FD_CLOSE),与之相关联的WSAEVENT对象被Signaled。
程序定义了两个全局数组,一个套接字数组,一个WSAEVENT对象数组,其大小都是MAXIMUM_WAIT_OBJECTS(64),两个数组中的元素一一对应。

同样的,这里的程序没有考虑两个问题,一是不能无条件的调用accept,因为我们支持的并发连接数有限。解决方法是将套接字按
MAXIMUM_WAIT_OBJECTS分组,每MAXIMUM_WAIT_OBJECTS个套接字一组,每一组分配一个工作者线程;或者采用WSAAccept代替accept,并回调自
己定义的Condition Function。第二个问题是没有对连接数为0的情形做特殊处理,程序在连接数为0的时候CPU占用率为100%。

四.重叠I/O模型

Winsock2的发布使得Socket I/O有了和文件I/O统一的接口。我们可以通过使用Win32文件操纵函数ReadFile和WriteFile来进行
Socket I/O。伴随而来的,用于普通文件I/O的重叠I/O模型和完成端口模型对Socket I/O也适用了。这些模型的优点是可以达到更佳的系
统性能,但是实现较为复杂,里面涉及较多的C语言技巧。例如我们在完成端口模型中会经常用到所谓的“尾随数据”。

1.用事件通知方式实现的重叠I/O模型

#include <winsock2.h>
#include <stdio.h>
#define PORT    5150
#define MSGSIZE 1024
#pragma comment(lib, "ws2_32.lib")
typedef struct
{
WSAOVERLAPPED overlap;
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_DATA g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS];
DWORD WINAPI WorkerThread(LPVOID);
void Cleanup(int);
int main()
{
WSADATA     wsaData;
SOCKET      sListen, sClient;
SOCKADDR_IN local, client;
DWORD       dwThreadId;
int         iaddrSize = sizeof(SOCKADDR_IN);
// Initialize Windows Socket library
WSAStartup(0x0202, &wsaData);
// 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(SOCKADDR_IN));
// Listen
listen(sListen, 3);
// Create worker thread
CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
while (TRUE)
{
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    g_CliSocketArr[g_iTotalConn] = sClient;
    
    // Allocate a PER_IO_OPERATION_DATA structure
    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();
    // Launch an asynchronous operation
    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();
return 0;
}
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
int   ret, index;
DWORD cbTransferred;
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)
    {
      // The connection was closed by client
      Cleanup(index);
    }
    else
    {
      // g_pPerIODataArr[index]->szMessage contains the received data
      g_pPerIODataArr[index]->szMessage[cbTransferred] = '\0';
      send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,\
        cbTransferred, 0);
      // Launch another asynchronous operation
      WSARecv(
        g_CliSocketArr[index],
        &g_pPerIODataArr[index]->Buffer,
        1,
        &g_pPerIODataArr[index]->NumberOfBytesRecvd,
        &g_pPerIODataArr[index]->Flags,
        &g_pPerIODataArr[index]->overlap,
        NULL);
    }
}
return 0;
}
void Cleanup(int index)
{
closesocket(g_CliSocketArr[index]);
WSACloseEvent(g_CliEventArr[index]);
HeapFree(GetProcessHeap(), 0, g_pPerIODataArr[index]);
if (index < g_iTotalConn - 1)
{
    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 <WINSOCK2.H>
#include <stdio.h>
#define PORT    5150
#define MSGSIZE 1024
#pragma comment(lib, "ws2_32.lib")
typedef struct
{
WSAOVERLAPPED overlap;
WSABUF        Buffer;
char          szMessage[MSGSIZE];
DWORD         NumberOfBytesRecvd;
DWORD         Flags; 
SOCKET        sClient;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;
DWORD WINAPI WorkerThread(LPVOID);
void CALLBACK CompletionROUTINE(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
SOCKET g_sNewClientConnection;
BOOL   g_bNewConnectionArrived = FALSE;
int main()
{
WSADATA     wsaData;
SOCKET      sListen;
SOCKADDR_IN local, client;
DWORD       dwThreadId;
int         iaddrSize = sizeof(SOCKADDR_IN);
// Initialize Windows Socket library
WSAStartup(0x0202, &wsaData);
// 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(SOCKADDR_IN));
// Listen
listen(sListen, 3);
// Create worker thread
CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
while (TRUE)
{
    // Accept a connection
    g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    g_bNewConnectionArrived = TRUE;
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
}
}
DWORD WINAPI WorkerThread(LPVOID lpParam)
{
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
while (TRUE)
{
    if (g_bNewConnectionArrived)
    {
      // Launch an asynchronous operation for new arrived connection
      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);
}
return 0;
}
void CALLBACK CompletionROUTINE(DWORD dwError,
                                DWORD cbTransferred,
                                LPWSAOVERLAPPED lpOverlapped,
                                DWORD dwFlags)
{
LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;

if (dwError != 0 || cbTransferred == 0)
{
    // Connection was closed by client
closesocket(lpPerIOData->sClient);
HeapFree(GetProcessHeap(), 0, lpPerIOData);
}
else
{
    lpPerIOData->szMessage[cbTransferred] = '\0';
    send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);
    
    // Launch another asynchronous operation
    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模型。然而,假若一个应用程序同时需要管理为数众多的套接字,那么采用这种模型,往往
    可以达到最佳的系统性能!但不幸的是,该模型只适用于Windows NT和Windows 2000操作系统。因其设计的复杂性,只有在你的应用程序需
    要同时管理数百乃至上千个套接字的时候,而且希望随着系统内安装的CPU数量的增多,应用程序的性能也可以线性提升,才应考虑采用
    “完成端口”模型。要记住的一个基本准则是,假如要为Windows NT或Windows 2000开发高性能的服务器应用,同时希望为大量套接字I/O请
    求提供服务(Web服务器便是这方面的典型例子),那么I/O完成端口模型便是最佳选择!(节选自《Windows网络编程》第八章)
    
    完成端口模型是我最喜爱的一种模型。虽然其实现比较复杂(其实我觉得它的实现比用事件通知实现的重叠I/O简单多了),但其效率是
惊人的。我在T公司的时候曾经帮同事写过一个邮件服务器的性能测试程序,用的就是完成端口模型。结果表明,完成端口模型在多连接(成千
上万)的情况下,仅仅依靠一两个辅助线程,就可以达到非常高的吞吐量。下面我还是从代码说起:

#include <WINSOCK2.H>
#include <stdio.h>
#define PORT    5150
#define MSGSIZE 1024
#pragma comment(lib, "ws2_32.lib")
typedef enum
{
RECV_POSTED
}OPERATION_TYPE;
typedef struct
{
WSAOVERLAPPED overlap;
WSABUF         Buffer;
char           szMessage[MSGSIZE];
DWORD          NumberOfBytesRecvd;
DWORD          Flags;
OPERATION_TYPE OperationType;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;
DWORD WINAPI WorkerThread(LPVOID);
int main()
{
WSADATA                 wsaData;
SOCKET                  sListen, sClient;
SOCKADDR_IN             local, client;
DWORD                   i, dwThreadId;
int                     iaddrSize = sizeof(SOCKADDR_IN);
HANDLE                  CompletionPort = INVALID_HANDLE_VALUE;
SYSTEM_INFO             systeminfo;
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
// Initialize Windows Socket library
WSAStartup(0x0202, &wsaData);
// Create completion port
CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
// Create worker thread
GetSystemInfo(&systeminfo);
for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)
{
    CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
}

// 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(SOCKADDR_IN));
// Listen
listen(sListen, 3);
while (TRUE)
{
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    // Associate the newly arrived client socket with completion port
    CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);
    
    // Launch an asynchronous operation for new arrived connection
    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->OperationType = RECV_POSTED;
    WSARecv(sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      NULL);
}
PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL);
CloseHandle(CompletionPort);
closesocket(sListen);
WSACleanup();
return 0;
}
DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
{
HANDLE                  CompletionPort=(HANDLE)CompletionPortID;
DWORD                   dwBytesTransferred;
SOCKET                  sClient;
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
while (TRUE)
{
    GetQueuedCompletionStatus(
      CompletionPort,
      &dwBytesTransferred,
      &sClient,
      (LPOVERLAPPED *)&lpPerIOData,
      INFINITE);
    if (dwBytesTransferred == 0xFFFFFFFF)
    {
      return 0;
    }
    
    if (lpPerIOData->OperationType == RECV_POSTED)
    {
      if (dwBytesTransferred == 0)
      {
        // Connection was closed by client
        closesocket(sClient);
        HeapFree(GetProcessHeap(), 0, lpPerIOData);        
      }
      else
      {
        lpPerIOData->szMessage[dwBytesTransferred] = '\0';
        send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0);
        
        // Launch another asynchronous operation for sClient
        memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
        lpPerIOData->Buffer.len = MSGSIZE;
        lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
        lpPerIOData->OperationType = RECV_POSTED;
        WSARecv(sClient,
          &lpPerIOData->Buffer,
          1,
          &lpPerIOData->NumberOfBytesRecvd,
          &lpPerIOData->Flags,
          &lpPerIOData->overlap,
          NULL);
      }
    }
}
return 0;
}

首先,说说主线程:
1.创建完成端口对象
2.创建工作者线程(这里工作者线程的数量是按照CPU的个数来决定的,这样可以达到最佳性能)
3.创建监听套接字,绑定,监听,然后程序进入循环
4.在循环中,我做了以下几件事情:
(1).接受一个客户端连接
(2).将该客户端套接字与完成端口绑定到一起(还是调用CreateIoCompletionPort,但这次的作用不同),注意,按道理来讲,此时传递
给CreateIoCompletionPort的第三个参数应该是一个完成键,一般来讲,程序都是传递一个单句柄数据结构的地址,该单句柄数据包含
了和该客户端连接有关的信息,由于我们只关心套接字句柄,所以直接将套接字句柄作为完成键传递;
(3).触发一个WSARecv异步调用,这次又用到了“尾随数据”,使接收数据所用的缓冲区紧跟在WSAOVERLAPPED对象之后,此外,还有操作
类型等重要信息。

在工作者线程的循环中,我们

1.调用GetQueuedCompletionStatus取得本次I/O的相关信息(例如套接字句柄、传送的字节数、单I/O数据结构的地址等等)
2.通过单I/O数据结构找到接收数据缓冲区,然后将数据原封不动的发送到客户端
3.再次触发一个WSARecv异步操作

六.五种I/O模型的比较

我会从以下几个方面来进行比较

*有无每线程64连接数限制

如果在选择模型中没有重新定义FD_SETSIZE宏,则每个fd_set默认可以装下64个SOCKET。同样的,受MAXIMUM_WAIT_OBJECTS宏的影响,
事件选择、用事件通知实现的重叠I/O都有每线程最大64连接数限制。如果连接数成千上万,则必须对客户端套接字进行分组,这样,势必增
加程序的复杂度。

相反,异步选择、用完成例程实现的重叠I/O和完成端口不受此限制。

*线程数
    除了异步选择以外,其他模型至少需要2个线程。一个主线程和一个辅助线程。同样的,如果连接数大于64,则选择模型、事件选择和用
事件通知实现的重叠I/O的线程数还要增加。

*实现的复杂度
我的个人看法是,在实现难度上,异步选择<选择<用完成例程实现的重叠I/O<事件选择<完成端口<用事件通知实现的重叠I/O

*性能
    由于选择模型中每次都要重设读集,在select函数返回后还要针对所有套接字进行逐一测试,我的感觉是效率比较差;完成端口和用完
成例程实现的重叠I/O基本上不涉及全局数据,效率应该是最高的,而且在多处理器情形下完成端口还要高一些;事件选择和用事件通知实现
的重叠I/O在实现机制上都是采用WSAWaitForMultipleEvents,感觉效率差不多;至于异步选择,不好比较。

winsock协议错误编码解析

         Windows协议可以应用到很多通用环境。例如,要检查网络,可以使用Windows套接字(WinSock)脚本来查看缓冲区发送和接收到的实际数据。WinSock类型还可以用于录制其他低级通信会话。通过他可以录制回放Vuser类型不支持的应用协议。使用VuGen,您可以录制应用程序对 Winsock.dll或Wsock32.dll的API调用,但是这种协议的错误提示代表是什么呢!其实每次winsock报的错误,有很多都是 winsock协议的错误编号!loadrunner把这写错误编号在调试信息中显示出来。下边我把一些winsock协议的错误编号都是什么意思给大家列举以下,希望对大家有帮助!

10004—WSAEINTR函数调用中断。该错误表明由于对WSACancelBlockingCall的调用,造成了一次调用被强行中断。
10009—WSAEBADF文件句柄错误。该错误表明提供的文件句柄无效。在MicrosoftWindowsCE下,socket函数可能返回这个错误,表明共享串口处于“忙”状态。
10013—WSAEACCES权限被拒。尝试对套接字进行操作,但被禁止。若试图在sendto或WSASendTo中使用一个广播地址,但是尚未用setsockopt和SO_BROADCAST这两个选项设置广播权限,便会产生这类错误。
10014—WSAEFAULT地址无效。传给Winsock函数的指针地址无效。若指定的缓冲区太小,也会产生这个错误。
10022 —WSAEINVAL参数无效。指定了一个无效参数。例如,假如为WSAIoctl调用指定了一个无效控制代码,便会产生这个错误。另外,它也可能表明套接字当前的状态有错,例如在一个目前没有监听的套接字上调用accept或WSAAccept.10024—WSAEMFILE打开文件过多。提示打开的套接字太多了。通常,Microsoft提供者只受到系统内可用资源数量的限制。
10035—WSAEWOULDBLOCK资源暂时不可用。对非锁定套接字来说,如果请求操作不能立即执行的话,通常会返回这个错误。比如说,在一个非暂停套接字上调用connect,就会返回这个错误。因为连接请求不能立即执行。
10036—WSAEINPROGRESS操作正在进行中。当前正在执行非锁定操作。一般来说不会出现这个错误,除非正在开发16位Winsock应用程序。
10037 —WSAEALREADY操作已完成。一般来说,在非锁定套接字上尝试已处于进程中的操作时,会产生这个错误。比如,在一个已处于连接进程的非锁定套接字上,再一次调用connect或WSAConnect.另外,服务提供者处于执行回调函数(针对支持回调例程的Winsock函数)的进程中时,也会出现这个错误。
10038—WSAENOTSOCK无效套接字上的套接字操作。任何一个把SOCKET句柄当作参数的Winsock函数都会返回这个错误。它表明提供的套接字句柄无效。
10039—WSAEDESTADDRREQ需要目标地址。这个错误表明没有提供具体地址。比方说,假如在调用sendto时,将目标地址设为INADDR_ANY(任意地址),便会返回这个错误。
10040 —WSAEMSGSIZE消息过长。这个错误的含义很多。如果在一个数据报套接字上发送一条消息,这条消息对内部缓冲区而言太大的话,就会产生这个错误。再比如,由于网络本身的限制,使一条消息过长,也会产生这个错误。最后,如果收到数据报之后,缓冲区太小,不能接收消息时,也会产生这个错误。
10041—WSAEPROTOTYPE套接字协议类型有误。在socket或WSASocket调用中指定的协议不支持指定的套接字类型。
比如,要求建立SOCK_STREAM类型的一个IP套接字,同时指定协议为IPPROTO_UDP,便会产生这样的错误。
10042—WSAENOPROTOOPT协议选项错误。表明在getsockopt或setsockopt调用中,指定的套接字选项或级别不明、未获支持或者无效。
10043——WSAEPROTONOSUPPORT不支持的协议。系统中没有安装请求的协议或没有相应的实施方案。比如,如果系统中没有安装TCP/IP,而试着建立TCP或UDP套接字时,就会产生这个错误。
10044—WSAESOCKTNOSUPPORT不支持的套接字类型。对指定的地址家族来说,没有相应的具体套接字类型支持。比如,在向一个不支持原始套接字的协议请求建立一个SOCK_RAW套接字类型时,就会产生这个错误。
10045 —WSAEOPNOTSUPP不支持的操作。表明针对指定的对象,试图采取的操作未获支持。通常,如果试着在一个不支持调用Winsock函数的套接字上调用了Winsock时,就会产生这个错误。比如,在一个数据报套接字上调用accept或WSAAccept函数时,就会产生这样的错误。
10046—WSAEPFNOSUPPORT不支持的协议家族。请求的协议家族不存在,或系统内尚未安装。多数情况下,这个错误可与WSAEAFNOSUPPORT互换(两者等价);后者出现得更为频繁。
10047 —WSAEAFNOSUPPORT地址家族不支持请求的操作。对套接字类型不支持的操作来说,在试着执行它时,就会出现这个错误。比如,在类型为 SOCK_STREAM的一个套接字上调用sendto或WSASendTo函数时,就会产生这个错误。另外,在调用socket或WSASocket函数的时候,若同时请求了一个无效的地址家族、套接字类型及协议组合,也会产生这个错误。
10048—WSAEADDRINUSE地址正在使用。正常情况下,每个套接字只允许使用一个套接字地址(例如,一个IP套接字地址由本地IP地址及端口号组成)。这个错误一般和bind、connect和 WSAConnect这三个函数有关。可在setsockopt函数中设置套接字选项SO_REUSEADDR,允许多个套接字访问同一个本地IP地址及端口号(详情见第9章)。
10049—WSAEADDRNOTAVAIL不能分配请求的地址。API调用中指定的地址对那个函数来说无效时,就会产生这样的错误。例如,若在bind调用中指定一个IP地址,但却没有对应的本地IP接口,便会产生这样的错误。另外,通过connect、 WSAConnect、sendto、WSASendTo和WSAJoinLeaf这四个函数为准备连接的远程计算机指定端口0时,也会产生这样的错误。
10050—WSAENETDOWN网络断开。试图采取一项操作时,却发现网络连接中断。这可能是由于网络堆栈的错误,网络接口的故障,或者本地网络的问题造成的。
10051—WSAENETUNREACH网络不可抵达。试图采取一项操作时,却发现目标网络不可抵达(不可访问)。这意味着本地主机不知道如何抵达一个远程主机。换言之,目前没有已知的路由可抵达那个目标主机。
10052—WSAENETRESET网络重设时断开了连接。由于“保持活动”操作检测到一个错误,造成网络连接的中断。
若在一个已经无效的连接之上,通过setsockopt函数设置SO_KEEPALIVE选项,也会出现这样的错误。
10053—WSAECONNABORTED软件造成连接取消。由于软件错误,造成一个已经建立的连接被取消。典型情况下,这意味着连接是由于协议或超时错误而被取消的。
10054 —WSAECONNRESET连接被对方重设。一个已经建立的连接被远程主机强行关闭。若远程主机上的进程异常中止运行(由于内存冲突或硬件故障),或者针对套接字执行了一次强行关闭,便会产生这样的错误。针对强行关闭的情况,可用SO_LINGER套接字选项和setsockopt来配置一个套接字(欲知详情,请参阅第9章)。
10055—WSAENOBUFS没有缓冲区空间。由于系统缺少足够的缓冲区空间,请求的操作不能执行。
10056 —WSAEISCONN套接字已经连接。表明在一个已建立连接的套接字上,试图再建立一个连接。要注意的是,数据报和数据流套接字均有可能出现这样的错误。使用数据报套接字时,假如事先已通过connect或WSAConnect调用,为数据报通信关联了一个端点的地址,那么以后试图再次调用 sendto或WSASendTo,便会产生这样的错误。
10057—WSAENOTCONN套接字尚未连接。若在一个尚未建立连接的“面向连接”套接字上发出数据收发请求,便会产生这样的错误。
10058 —WSAESHUTDOWN套接字关闭后不能发送。表明已通过对shutdown的一次调用,部分关闭了套接字,但事后又请求进行数据的收发操作。要注意的是,这种错误只会在已经关闭的那个数据流动方向上才会发生。举个例子来说,完成数据发送后,若调用shutdown,那么以后任何数据发送调用都会产生这样的错误。
10060—WSAETIMEDOUT连接超时。若发出了一个连接请求,但经过规定的时间,远程计算机仍未作出正确的响应(或根本没有任何响应),便会发生这样的错误。要想收到这样的错误,通常需要先在套接字上设置好SO_SNDTIMEO和SO_RCVTIMEO选项,然后调用 connect及WSAConnect函数。
要想了解在套接字上设置SO_SNDTIMEO和SO_RCVTIMEO选项的详情,可参考第9章。
10061—WSAECONNREFUSED连接被拒。由于被目标机器拒绝,连接无法建立。这通常是由于在远程机器上,没有任何应用程序可在那个地址之上,为连接提供服务。
10064 —WSAEHOSTDOWN主机关闭。这个错误指出由于目标主机关闭,造成操作失败。然而,应用程序此时更有可能收到的是一条 WSAETIMEDOUT(连接超时)错误,因为对方关机的情况通常是在试图建立一个连接的时候发生的。10065—WSAEHOSTUNREACH没有到主机的路由。应用程序试图访问一个不可抵达的主机。该错误类似于WSAENETUNREACH.10067—WSAEPROCLIM进程过多。有些 Winsock服务提供者对能够同时访问它们的进程数量进行了限制。
10091—WSASYSNOTREADY网络子系统不可用。调用WSAStartup时,若提供者不能正常工作(由于提供服务的基层系统不可用),便会返回这种错误。
10092—WSAVERNOTSUPPORTEDWinsock.dll版本有误。表明不支持请求的Winsock提供者版本。
10093—WSANOTINITIALISEDWinsock尚未初始化。尚未成功完成对WSAStartup的一次调用。
10101—WSAEDISCON正在从容关闭。这个错误是由WSARecv和WSARecvFrom返回的,指出远程主机已初始化了一次从容关闭操作。该错误是在像ATM这样的“面向消息”协议上发生的。
10102 —WSAENOMORE找不到更多的记录。这个错误自WSALookupServiceNext函数返回,指出已经没有留下更多的记录。这个错误通常可与 WSA_E_NO_MORE互换使用。在应用程序中,应同时检查这个错误以及WSA_E_NO_MORE.10103—WSAECANCELLED操作被取消。这个错误指出当WSALookupServiceNext调用仍在处理期间,发出了对WSALookupServiceEnd(服务中止)的一个调用。此时,WSALookupServiceNext便会返回这个错误。这个错误代码可与WSA_E_CANCELLED互换使用。作为应用程序,应同时检查这个错误以及WSA_E_CANCELLED.10104—WSAEINVALIDPROCTABLE进程调用表无效。该错误通常是在进程表包含了无效条目的情况下,由一个服务提供者返回的。欲知服务提供者的详情,可参考第14章。
10105—WSAEINVALIDPROVIDER无效的服务提供者。这个错误同服务提供者关联在一起,在提供者不能建立正确的Winsock版本,从而无法正常工作的前提下产生。
10106—WSAEPROVIDERFAILEDINIT提供者初始化失败。这个错误同服务提供者关联在一起,通常见于提供者不能载入需要的DLL时。
10107—WSASYSCALLFAILURE系统调用失败。表明绝对不应失败的一个系统调用却令人遗憾地失败了。
10108—WSASERVICE_NOT_FOUND找不到这样的服务。这个错误通常与注册和名字解析函数相关,在查询服务时产生(第10章对这些函数进行了详尽解释)。该错误表明,在给定的名字空间内,找不到请求的服务。
10109—WSATYPE_NOT_FOUND找不到类的类型。该错误也与注册及名字解析函数关联在一起,在处理服务类(ServiceClass)时发生。若注册好一个服务的实例,它必须引用一个以前通过WSAInstallServiceClass安装好的服务。
10110 —WSA_E_NO_MORE找不到更多的记录。这个错误是自WSALookupServiceNext调用返回的,指出已经没有剩下的记录。该错误通常可与WSAENOMORE互换使用。作为一个应用程序,应同时检查这个错误以及WSAENOMORE.10111—WSA_E_CANCELLED操作被取消。该错误指出在对WSALookupServiceNext的调用尚未完成的时候,又发出了对WSALookupServiceEnd(中止服务)的一个调用。这样,WSALookupServiceNext就会返回该错误。这个错误代码可与WSAECANCELLED互换使用。作为一个应用程序,应同时检查这个错误以及WSAECANCELLED.10112—WSAEREFUSED查询被拒。由于被主动拒绝,所以一个数据库查询操作失败。
11001—WSAHOST_NOT_FOUND主机没有找到。这个错误是在调用gethostbyname和gethostbyaddr时产生的,表明没有找到一个授权应答主机(AuthoritativeAnswerHost)。
11002—WSATRY_AGAIN非授权主机没有找到。这个错误也是在调用gethostbyname和gethostbyaddr时产生的,表明没有找到一个非授权主机,或者遇到了服务器故障。
11003—WSANO_RECOVERY遇到一个不可恢复的错误。这个错误也是在调用gethostbyname和gethostbyaddr时产生的,指出遇到一个不可恢复的错误,应再次尝试操作。
11004—WSANO_DATA没有找到请求类型的数据记录。这个错误也是在调用gethostbyname和gethostbyaddr时产生的,指出尽管提供的名字有效,但却没有找到与请求类型对应的数据记录。
11005—WSA_QOS_RECEIVERS至少有一条预约消息抵达。这个值同IP服务质量(QoS)有着密切的关系,其实并不是一个真正的“错误”(QoS的详情见第12章)。它指出网络上至少有一个进程希望接收QoS通信。
11006—WSA_QOS_SENDERS至少有一条路径消息抵达。这个值同QoS关联在一起,其实更像一种状态报告消息。它指出在网络上,至少有一个进程希望进行QoS数据的发送。
11007—WSA_QOS_NO_SENDERS没有QoS发送者。这个值同QoS关联在一起,指出不再有任何进程对QoS数据的发送有兴趣。请参阅第12章,了解在发生这样的错误时,对所发生情况的一系列完整说明。
11008—WSA_QOS_NO_RECEIVERS没有QoS接收者。这个值同QoS关联在一起,指出不再有任何进程对QoS数据的接收有兴趣。请参阅第12章,查阅对这个错误的完整说明。
11009—WSA_QOS_REQUEST_CONFIRMED预约请求已被确认。QoS应用可事先发出请求,希望在批准了自己对网络带宽的预约请求后,收到通知。若发出了这样的请求,一旦批准,便会收到这样的消息。请参阅第12章,了解对此消息的详细说明。
11010—WSA_QOS_ADMISSION_FAILURE缺乏资源致错。资源不够,以至于无法满足QoS带宽请求。
11011—WSA_QOS_POLICY_FAILURE证书无效。表明发出QoS预约请求的时候,要么用户并不具备正确的权限,要么提供的证书无效。
11012—WSA_QOS_BAD_STYLE未知或冲突的样式。QoS应用程序可针对一个指定的会话,建立不同的过滤器样式。若出现这一错误,表明指定的样式类型要么未知,要么存在冲突。请参阅第12章,了解对过滤器样式的详细说明。
11013—WSA_QOS_BAD_OBJECT无效的FILTERSPEC结构或者提供者特有对象。假如为QoS对象提供的FILTERSPEC结构无效,或者提供者特有的缓冲区无效,便会返回这样的错误,详见第12章。
11014—WSA_QOS_TRAFFIC_CTRL_ERRORFLOWSPEC有问题。假如通信控制组件发现指定的FLOWSPEC参数存在问题(作为QoS对象的一个成员传递),便会返回这样的错误。
11015—WSA_QOS_GENERIC_ERROR常规QoS错误。这是一个比较泛泛的错误;假如其他QoS错误都不适合,便返回这个错误。
6—WSA_INVALID_HANDLE指定的事件对象无效。若使用与Win32函数对应的Winsock函数,便有可能产生这样的Win32错误。它表明传递给WSAWaitForMultipleEvents的一个句柄是无效的。
8—WSA_NOT_ENOUGH_MEMORY内存不够。这个Win32错误指出内存数量不足,无法完成指定的操作。
87—WSA_INVALID_PARAMETER一个或多个参数无效。这个Win32错误表明传递到函数内部的参数无效。假若事件计数参数无效,那么在执行WSAWaitForMultipleEvents的时候,也会发生这样的错误。
258—WSA_WAIT_TIMEOUT操作超时。这个Win32错误指出重叠I/O操作未在规定的时间内完成。
995—WSA_OPERATION_ABORTED重叠操作被取消。这个Win32错误指出由于套接字的关闭,造成一次重叠I/O操作的取消。
除此以外,该错误也可能在执行SIO_FLUSH这个I/O控制命令时出现。
996—WSA_IO_INCOMPLETE重叠I/O事件对象未处于传信状态。这个Win32错误也和重叠I/O操作密切相关,在调用WSAGetOverlappedResults函数的时候产生,指出重叠I/O操作尚未完成。
997—WSA_IO_PENDING重叠操作将在以后完成。用Winsock函数发出一次重叠I/O操作时,若出现这样的Win32错误,便表明操作尚未完成,而且会在以后的某个时间完成。

socket编程五种模型的更多相关文章

  1. IO的五种模型

    为了区分IO的五种模型,下面先来看看同步与异步.阻塞与非阻塞的概念差别. 同步:所谓同步,就是在发出一个功能调用时,在没有得到结果之前,该调用就不返回.按照这个定义,其实绝大多数函数都是同步调用(例如 ...

  2. 图解I/O的五种模型

    1.1 五种I/O模型 1)阻塞I/O 2)非阻塞I/O 3)I/O复用 4)事件(信号)驱动I/O 5)异步I/O 1.2 为什么要发起系统调用? 因为进程想要获取磁盘中的数据,而能和磁盘打交道的只 ...

  3. 2. 彤哥说netty系列之IO的五种模型

    你好,我是彤哥,本篇是netty系列的第二篇. 欢迎来我的公从号彤哥读源码系统地学习源码&架构的知识. 简介 本文将介绍linux中的五种IO模型,同时也会介绍阻塞/非阻塞与同步/异步的区别. ...

  4. IO 的五种模型是什么

    目录 前言 用户空间和内核空间 IO 五种模型 阻塞型 IO 非阻塞 IO IO 多路复用 信号驱动 IO 异步 IO 总结 阻塞和非阻塞 同步与异步 前言 我们经常看到阻塞/非阻塞,同步/异步这两组 ...

  5. 【网络IO系列】IO的五种模型,BIO、NIO、AIO、IO多路复用、 信号驱动IO

    前言 在上一篇文章中,我们了解了操作系统中内核程序和用户程序之间的区别和联系,还提到了内核空间和用户空间,当我们需要读取一条数据的时候,首先需要发请求告诉内核,我需要什么数据,等内核准备好数据之后 , ...

  6. socket编程的select模型

    在掌握了socket相关的一些函数后,套接字编程还是比较简单的,日常工作中碰到很多的问题就是客户端/服务器模型中,如何让服务端在同一时间高效的处理多个客户端的连接,我们的处理办法可能会是在服务端不停的 ...

  7. Linux-I/O五种模型

    一. 概念说明 在进行解释之前,首先要说明几个概念: 用户空间和内核空间 进程切换 进程的阻塞 文件描述符 缓存 I/O 同步(Sync)/异步(Async) 阻塞(Block)/非阻塞(Unbloc ...

  8. 从 Socket 编程谈谈 IO 模型(三)

    快过年啦,估计很多朋友已在摸鱼的路上.而我为了兄弟们年后的追逐,却在苦苦寻觅.规划,导致文章更新晚了些,各位猿粉谅解. 上期分享,我们结合新春送祝福的场景,通过一坨坨的代码让 BIO.NIO 编程过程 ...

  9. linux第7天 I/O的五种模型, select

    服务器端避免僵尸进程的方法: 1)通过忽略SIGCHLD信号,解决僵尸进程 signal(SIGCHLD, SIG_IGN) 2)通过wait方法,解决僵尸进程 signal(SIGCHLD, han ...

随机推荐

  1. 如何获得Windows 8中已记住的WIFI的明文密码

    网上很流行的一种查看WIFI密码明文的方法,如下: 今天遇到了一种状况,就是如果不连WIFI的情况我能抓到这个密码吗?(实在不想开口问同事密码多少,只能苦逼的自己想办法了o(︶︿︶)o ) 答案当然是 ...

  2. 解决IE无法解析json的方法

    一.原始方法eval() 二.json插件--github开源插件:json-js/json2.js https://github.com/douglascrockford/JSON-js/blob/ ...

  3. 简易的highcharts公共绘图模块封装--基于.net mvc

    运行效果: 之所以选择这个图表插件,是因为它较其他同类插件轻量且中文文档详细完整,Demo丰富,配置使用简单.具体内容请登录中文官网:http://www.hcharts.cn/ 项目详细: 项目环境 ...

  4. jquery 只有二级下拉菜单

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  5. Java:对象的序列化

    一.对象序列化机制 序列化机制允许将实现序列化的Java对象转换为字节序列,这些字节序列可以被保存在磁盘上或通过网络传输,以备以后重新恢复原来的对象: 序列化机制使得对象可以脱离程序的运行而独立存在: ...

  6. linux创建交换分区

    一.SWAP 概述 当系统的物理内存不够用的时候,就需要将物理内存中的一部分空间释放出来,以供当前运行的程序使用.那些被释放的空间可能来自一些很长时间没有什么操作的程序,这些被释放的空间被临时保存到S ...

  7. eclipse/myeclipse选中编辑区域文件,Package Explorer定位文件所在项目及目录

    eclipse/myeclipse选中编辑区域文件,Package Explorer定位文件所在项目及目录 1. 打开Package Explorer(若没有,可以按照如下路径点击: Window菜单 ...

  8. ByteArrayInputStream 和 ByteArrayOutputStream

    package java.io; /** * A <code>ByteArrayInputStream</code> contains * an internal buffer ...

  9. 最常用的动态sql语句梳理——分享给使用Mybatis的小伙伴们!

    公司项目中一直使用Mybatis作为持久层框架,自然,动态sql写得也比较多了,最常见的莫过于在查询语句中使用if标签来动态地改变过滤条件了.Mybatis的强大特性之一便是它的动态sql,免除了拼接 ...

  10. HDUOJ Clear All of Them I 状压DP

    Clear All of Them I Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 122768/62768 K (Java/Oth ...