介绍
WinSock是Windows提供的包含了一系列网络编程接口的套接字程序库。在这篇文章中，我们将介绍如何把它的非阻塞模式引入到应用程序中。

阻塞模式WinSock.下述伪代码给出了阻塞模式下WinSock的使用方式。
//服务器
WSAStartup();
SOCKET server = socket();
bind(server);
listen(server);
SOCKET client = accept(server);
send(client);
recv(client);
closesocket(client);
closesocket(server); 
WSACleanup();

//客户端
WSAStartup();
SOCKET client=socket(); 
bind(client);
ServerAddress server;
connect(client, server);
recv(client);
send(client);
closesocket(client);
WSACleanup();
代码中，服务器端的accept()，客户端的connect()，以及服务器和客户端中共同的recv()、send()函数均会产生阻塞。
服务器在调用accept()后不会返回，直到接收到客户端的连接请求；
客户端在调用connect()后不会返回，直到对服务器连接成功或者失败；
服务器和客户端在调用recv()后不会返回，直到接收到并读取完一条消息；
服务器和客户端在调用send()后不会返回，直到发送完待发送的消息。
如果这两段代码被放在Windows程序的主线程中，你会发现消息循环被阻塞，程序不再响应用户输入及重绘请求。为了解决这个问题，
你可能会想到开辟另外一个线程来运行这些代码。这是可行的，但是考虑到每个SOCKET都不应该被其他SOCKET的操作所阻塞，是不是
需要为每个SOCKET开辟一个线程？再考虑到同一SOCKET的一个读写操作也不应该被另外一个读写操作所阻塞，是不是应该再为每个
SOCKET的读和写分别开辟一个线程？一般来说，这种自实现的多线程解决方案带来的诸多线程管理方面的问题，是你绝对不会想要遇
到的。
 
非阻塞模式WinSock
所幸的是，WinSock同时提供了非阻塞模式，并提出了几种I/O模型。最常见的I/O模型有select模型、WSAAsyncSelect模型及
WSAEventSelect模型，下面选择其中的WSAAsyncSelect模型进行介绍。使用WSAAsyncSelect模型将非阻塞模式引入到应用程序中的过
程看起来很简单，事实上你只需要多添加一个函数就够了。
int WSAAsyncSelect(SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent);
该函数会自动将套接字设置为非阻塞模式，并且把发生在该套接字上且是你所感兴趣的事件，以Windows消息的形式发送到指定的窗口，
你需要做的就是在传统的消息处理函数中处理这些事件。参数hWnd表示指定接受消息的窗口句柄；参数wMsg表示消息码值（这意味着你
需要自定义一个Windows消息码）；参数IEvent表示你希望接受的网络事件的集合，它可以是如下值的任意组合：FD_READ, FD_WRITE, 
FD_OOB, FD_ACCEPT, FD_CONNECT, FD_CLOSE 之后，就可以在我们熟知的Windows消息处理函数中处理这些事件。如果在某一套接字s上
发生了一个已命名的网络事件，应用程序窗口hWnd会接收到消息wMsg。参数wParam即为该事件相关的套接字s；参数lParam的低字段指
明了发生的网络事件，lParam的高字段则含有一个错误码，事件和错误码可以通过下面的宏从lParam中取出：
#define WSAGETSELECTEVENT(lParam) LOWORD(lParam)
#define WSAGETSELECTERROR(lParam) HIWORD(lParam)
下面继续使用伪代码来帮助阐述如何将上一节的阻塞模式WinSock应用升级到非阻塞模式。
首先自定义一个Windows消息码，用于标识我们的网络消息。

#define WM_CUSTOM_NETWORK_MSG (WM_USER + 100) 
//服务器端，在监听之前，将监听套接字置为非阻塞模式，并且标明其感兴趣的事件为FD_ACCEPT。
WSAAsyncSelect(server, wnd, WM_CUSTOM_NETWORK_MSG, FD_ACCEPT); 
listen(server);

//客户端，在连接之前，将套接字置为非阻塞模式，并标明其感兴趣的事件为FD_CONNECT。
WSAAsyncSelect(client, wnd, WM_CUSTOM_NETWORK_MSG, FD_CONNECT);
ServerAddress?server;
connect(client,?server);

//接着，在Windows消息处理函数中，我们将处理监听事件、连接事件、及读写事件，方便起见，这里将服务器和客户端的处理代码放在
了一起。
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)    
{    
    switch (message)    
    {
    case WM_CUSTOM_NETWORK_MSG: // 自定义的网络消息码    
        {    
            SOCKET socket = (SOCKET)wParam; // 发生网络事件的套接字    
            long event = WSAGETSELECTEVENT(lParam); // 事件    
            int error = WSAGETSELECTERROR(lParam); // 错误码    
    
            switch (event)    
            {    
            case FD_ACCEPT: // 服务器收到新客户端的连接请求    
                {    
                    // 接收到客户端连接，分配一个客户端套接字    
                    SOCKET client = accept(socket);     
                    // 将新分配的客户端套接字置为非阻塞模式，并标明其感兴趣的事件为读、写及关闭    
                    WSAAsyncSelect(client, hWnd, message, FD_READ | FD_WRITE | FD_CLOSE);    
                }    
                break;    
            case FD_CONNECT: // 客户端连接到服务器的操作返回结果    
                {    
                    // 成功连接到服务器，将客户端套接字置为非阻塞模式，并标明其感兴趣的事件为读、写及关闭    
                    WSAAsyncSelect(socket, hWnd, message, FD_READ | FD_WRITE | FD_CLOSE);    
                }    
                break;    
            case FD_READ: // 收到网络包，需要读取    
                {    
                    // 使用套接字读取网络包    
                    recv(socket);    
                }    
                break;    
            case FD_WRITE:    
                {    
                    // FD_WRITE的处理后面会具体讨论    
                }    
                break;    
            case FD_CLOSE: // 套接字的连接方(而非本地socket)关闭消息    
                {    
                }    
                break;    
            default:    
                break;    
            }    
        }    
        break;    
    …    
    }    
    …    
}    
以上就是非阻塞模式WinSock的应用框架，WSAAsyncSelect模型将套接字和Windows消息机制很好地粘合在一起，为用户异步SOCKET应用提供
了一种较优雅的解决方案。

扩展讨论
WinSock在系统底层为套接字收发网络数据各提供一个缓冲区，接收到的网络数据会缓存在这里等待应用程序读取，待发送的网络数据也会先
写进这里之后通过网络发送。相关的，针对FD_READ和FD_WRITE事件的读写处理，因涉及的内容稍微复杂而容易使人困惑，这里需要特别进行
讨论。在FD_READ事件中，使用recv()函数读取网络包数据时，由于事先并不知道完整网络包的大小，所以需要多次读取直到读完整个缓冲区
。这就需要类似如下代码的调用：
void* buf = 0;    
int size = 0;    
while (true)    
{    
    char tmp[128];    
    int bytes = recv(socket, tmp, 128, 0);    
    if (bytes <= 0)    
        break;    
    else    
    {    
        int new_size = size + bytes;    
        buf = realloc(buf, new_size);    
        memcpy((void*)(((char*)buf) + size), tmp, bytes);    
        size = new_size;    
    }    
}    
//此时数据已经从缓冲区全部拷贝到buf中，你可以在这里对buf做一些操作      
free(buf);    
这一切看起来都没有什么问题，但是如果程序运行起来，你会收到比预期多出许多的FD_READ事件。如MSDN所述，正常的情况下，应用程序应
当为每一个FD_READ消息仅调用一次recv()函数。如果一个应用程序需要在一个FD_READ事件处理中调用多次recv()，那么它将会收到多个
FD_READ消息，因为每次未读完缓冲区的recv()调用，都会重新触发一个FD_READ消息。针对这种情况，我们需要在读取网络包前关闭掉FD_READ
消息通知，读取完这后再进行恢复，关闭FD_READ消息的方法很简单，只需要调用WSAAsyncSelect时参数lEvent中FD_READ字段不予设置即可。

//关闭FD_READ事件通知    
WSAAsyncSelect(socket, hWnd, message, FD_WRITE | FD_CLOSE);    
// 读取网络包    
…    
// 再次打开FD_READ事件通知    
WSAAsyncSelect(socket, hWnd, message, FD_WRITE | FD_CLOSE | FD_READ);

第二个需要讨论的是FD_WRITE事件。这个事件指明缓冲区已经准备就绪，有了多出的空位可以让应用程序写入数据以供发送。该事件仅在两种
情况下被触发：
1. 套接字刚建立连接时，表明准备就绪可以立即发送数据。
2. 一次失败的send()调用后缓冲区再次可用时。如果系统缓冲区已经被填满，那么此时调用send()发送数据，将返回SOCKET_ERROR，使用
WSAGetLastError()会得到错误码WSAEWOULDBLOCK表明被阻塞。这种情况下当缓冲区重新整理出可用空间后，会向应用程序发送FD_WRITE消息，
示意其可以继续发送数据了。

所以说收到FD_WRITE消息并不单纯地等同于这是使用send()的唯一时机。一般来说，如果需要发送消息，直接调用send()发送即可。如果该次
调用返回值为SOCKET_ERROR且WSAGetLastError()得到错误码WSAEWOULDBLOCK，这意味着缓冲区已满暂时无法发送，此刻我们需要将待发数据
保存起来，等到系统发出FD_WRITE消息后尝试重新发送。也就是说，你需要针对FD_WRITE构建一套数据重发的机制，文末的工程源码里包含有
这套机制以供大家参考，这里不再赘述。

结语
至此，如何在非阻塞模式下使用WinSock进行编程介绍完毕，这个框架可以满足大多数网络游戏客户端及部分服务器的通信需求。更多应用层面
上的问题（如TCP粘包等）这里没有讨论，或许会在以后的文章中给出。

WSAAsyncSelect模型(同步I/O模型)

这里为什么说他是同步的，就是因为实际的数据的Copy是同步进行///的，而不是异步的，只是相应的通知机制(通知数据已经准备好了)，是异步的

这个模型允许应用程序以Windows消息的形式可在一个套接字上，接收网络事件通知
具体的做法是在建好一个套接字后，调用WSAAsyncSelect函数。
在我看来，WSAAsyncSelect是最简单的一种Winsock I/O模型（之所以说它简单是因为一个主线程就搞定了）。
这里，我们需要做的仅仅是：
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模型是Windows socket的一个异步IO模型。利用该模型可以接收以Windows消息为基础的网络事件。Windows sockets应用程序在创建套接字后，调用WSAAsyncSelect函数注册感兴趣的网络事件，当该事件发生时Windows窗口收到消息，应用程序就可以对接收到的网络时间进行处理。

WSAAsyncSelect是select模型的异步版本。在应用程序使用select函数时会发生阻塞现象。可以通过select的timeout参数设置阻塞的时间。在设置的时间内，select函数等待，直到一个或多个套接字满足可读或可写的条件。

而WSAAsyncSelect是非阻塞的。Windows sockets程序在调用recv或send之前，调用WSAAsyncSelect注册网络事件。WSAAsyncSelect函数立即返回。当系统中数据准备好时，会向应用程序发送消息。此此消息的处理函数中可以调用recv或send进行接收或发送数据。

WSAAsyncSelect模型与select模型的相同点是它们都可以对多个套接字进行管理。但它们也有不小的区别。首先WSAAsyncSelect模型是异步的，且通知方式不同。更重要的一点是：WSAAsyncSelect模型应用在基于消息的Windows环境下，使用该模型时必须创建窗口，而select模型可以广泛应用在Unix系统，使用该模型不需要创建窗口。最后一点区别：应用程序在调用WSAAsyncSelect函数后，套接字就被设置为非阻塞状态。而使用select函数不改变套接字的工作方式。

WSAAsyncSelect函数。

该函数告诉系统当网络事件发生时为套接字发送消息。声明如下：

[html] view plaincopy
  1. int WSAAsyncSelect(
  2. SOCKET s,
  3. HWND hWnd,
  4. u_int wMsg,
  5. long lEvent);

s为需要通知的套接字。

hWnd为当网络事件发生时接收消息的窗口句柄。

wMsg为当网络事件发生时窗口收到的消息。在此消息的响应函数内对网络事件进行处理。

lEvent为应用程序感兴趣的网络事件集合。

应用程序调用该函数后自动将套接字设置为非阻塞模式。通常用户自定义消息应该在WM_USER的基础之上定义。如WM_USER+1，以避免与Windows预定义的消息发生混淆。

网络事件可以有以下几种：

FD_READ：套接字可读通知。

FD_WRITE：可写通知。

FD_ACCEPT：服务器接收连接的通知。

FD_CONNECT：有客户连接通知。

FD_OOB：外带数据到达通知。

FD_CLOSE：套接字关闭通知。

FD_QOS：服务质量发生变化通知。

FD_GROUP_QOS：组服务质量发生变化通知。

FD_ROUTING_INTERFACE_CHANGE：与路由器接口发生变化的通知。

FD_ADDRESS_LIST_CHANGE：本地地址列表发生变化的通知。

开发人员应向应用程序注册感兴趣的网络事件。可以将它们按位或并传给lEvent函数。如：

[cpp] view plaincopy
  1. WSAAsyncSelect(s,hWnd,WM_SOCKET,FD_CONNECT|FD_READ|FD_CLOSE);

上述代码表示：当套接字连接到来、有数据可读或这套接字关闭的网络事件发生时，WM_SOCKET消息就会发送给hWnd为句柄的窗口。

消息处理函数。

消息处理函数是对网络事件发生时窗口消息的处理。它的声明如下：

[cpp] view plaincop
  1. LRESULT CALLBACK WindowProc(
  2. HWND hWnd,
  3. UINT uMsg,
  4. WPARAM wParam,
  5. LPARAM lParam)

hWnd为窗口句柄。

uMsg为当网络事件发生时的消息。

wParam为消息参数。该参数表明发生网络事件的套接字。

lParam也为消息参数。低字节表明已发生的网络事件。高字节包含错误代码。

在Windows sockets应用程序中，当WindowProc接收到网络消息时，在该函数内执行下面的步骤：

1：读取lParam的高字节，判断是否有错误发生。可以使用WSAGETSElECTERROR宏。

2：如果没有错误，读取lParam的低字节，检查发生了什么网络事件，可以使用WSAGETSELECTEVENT宏。

WSAGETSElECTERROR和WSAGETSELECTEVENT宏定义如下：

[cpp] view plaincopy
  1. #define WSAGETSElECTERROR(lParam)  LOWORD(lParam)
  2. #define WSAGETSELECTEVENT(lParam)  HIWORD(lParam)

接下来就需要创建窗口和将网络消息与消息处理函数关联起来。如果使用MFC可以使用MFC提供的宏来进行处理。

注意：多次调用WSAAsyncSelect时，最后一次调用会取消前面注册的网络事件。

因为调用accept接受的套接字和监听套接字具有同样的属性。所以，任何为监听套接字设置的网络事件对接受套接字同样起作用。如果一个监听套接字请求FD_ACCEPT、FD_READ和FD_WRITE网络事件。则在该监听套接字上接受的任何套接字也会请求FD_ACCEPT，FD_READ和FD_WRITE网络事件。

FD_CLOSE网络事件用来判断套接字是否已经关闭。错误代码会指出套接字是从容关闭还是硬关闭。如果为0，为从容关闭。若错误代码为WSAECONNRESET，则套接字是硬关闭。调用closesocket不会投递FD_CLOSE事件。

发生网络事件的条件。

下列条件下会发生FD_READ事件：

1：当调用WSAAsyncSelect函数时，如果当前有数据可读。

2：当数据到达并且没有发送FD_READ网络事件时。

3：调用recv()或这recvfrom,如果仍有数据可读里。

下列情况下会发生FD_WRITE事件：

1：调用WSAAsyncSelect函数时，如果能够发送数据时。

2：connect或者accept函数后，连接已经建立时。

3：调用send或者sendto函数，返回WSAWOULDBLOCK错误后，再次调用send()或者sendto函数可能成功时。因为此时可能是套接字还处于不可写状态，多次调用直到调用成功为止。

WSAAsyncSelect的优势与不足。

该模型是在基于消息的Windows环境下开发应用程序。开发人员可以像处理其他消息一样，对网络事件进行处理。而且为确保接受所有数据提供了很好的机制。

不足：由于该模型基于Windows消息机制，必须在应用程序中创建窗口。虽然可以在开发中，确定是否显示该窗口。 由于调用WSAAsyncSelect函数后自动将套接字设置为非阻塞状态，当应用程序接收到网络事件时，未必能够成功返回。这无疑增加了使用该模型的难度。

接下来展示一个使用如何WSAAsyncSelect模型的例子。该程序使用WSAAsyncSelect模型管理接受的客户端套接字。编码步骤如下：

1：声明自定义消息。如WM_SOCKET

2：声明窗口例程。

3：将自定义消息与消息处理函数相关联。

4：初始化套接字动态库，创建套接字。

5：调用WSAAsyncSelect注册感兴趣的网络事件。本例服务器感兴趣的网络事件有FD_ACCEPT和FD_CLOSE。

6：绑定套接字开始监听。

一：声明自定义消息：

[cpp] view plaincopy
  1. #define WM_SOCKET WM_USER+1 //套接字消息。

除了声明自定义消息外还需要声明最大字符串长度、服务器监听端口、数据缓冲区。

[cpp] view plaincopy
  1. #define MAX_STRING 100     //最大字符串长度。
  2. #define SERVERPORT 5000    //服务器端口。
  3. #define MAX_SIZE_BUF 1024  //数据缓冲区长度。

二：声明消息处理函数并与消息关联：

1：在窗口类头文件中声明消息处理函数。如：

[cpp] view plaincopy
  1. afx_msg LRESULT onWmSocket(WPARAM wParam, LPARAM lParam);

2：在消息映射宏中将自定义消息如声明的消息处理函数关联：

[cpp] view plaincopy
  1. ON_MESSAGE(WM_SOCKET,&onWmSocket)

3：实现消息处理函数：

[cpp] view plaincopy
  1. LRESULT CuserdefinedMessageTestDlg::onWmSocket( WPARAM wParam, LPARAM lParam )
  2. {
  3. if(WSAGETSELECTERROR(lParam))
  4. {
  5. m_list.deleteNode(wParam);//wParam为发生消息的套接字。出现错误，则从链表中将该套接字对应的CClient类对象删除。
  6. return false;
  7. }
  8. else
  9. {
  10. switch(WSAGETSELECTEVENT(lParam))
  11. {
  12. case FD_ACCEPT://接受客户端连接请求。
  13. {
  14. SOCKET sAccept;
  15. if((sAccept==accept(wParam,NULL,NULL)==INVALID_SOCKET))
  16. break;
  17. m_list.add(sAccept);
  18. //在新接受的套接字发生FD_READ,FD_WRITE,FD_CLOSE网络事件发生，发送WM_SOCKET消息；
  19. WSAAsyncSelect(sAccept,this->m_hWnd,WM_SOCKET,FD_READ|FD_WRITE|FD_CLOSE);
  20. }
  21. break;
  22. case FD_READ://可读，接收数据。
  23. {
  24. CClient *pClinet=GetClient(wParam);//根据套接字，获取客户端节点。
  25. pClient->RecvData();
  26. }
  27. break;
  28. case FD_WRITE://可写，发送数据。
  29. {
  30. CClient*pClient=GetClient(wParam);
  31. pClient->SendData();
  32. }
  33. break;
  34. case FD_CLOSE://对方关闭套接字连接。
  35. {
  36. if(WSAGETSELECTERROR(lParam)==0)
  37. {
  38. //从容关闭。
  39. }
  40. else if(WSAGETSELECTERROR(lParam)==WSAECONNREFUSED)
  41. {
  42. //硬关闭。
  43. }
  44. m_list.deleteNode(wParam);
  45. }
  46. break;
  47. default:
  48. break;
  49. }
  50. }
  51. return 0;
  52. }

三：创建套接字并注册感兴趣的网络事件.

1:初始化套接字动态库，并创建套接字。

[cpp] view plaincopy
  1. WSADATA wsa;
  2. int ret=WSAStartup(MAKEWORD(2,2),&wsa);
  3. ListenSocket=socket(AF_INET,SOCK_STREAM,0);
  4. if(ListenSocket==INVALID_SOCKET)
  5. {
  6. return false;
  7. }

2：注册感兴趣的网络事件：

[cpp] view plaincopy
  1. WSAAsyncSelect(ListenSocket,this,WM_SOCKET,FD_ACCEPT|FD_CLOSE);

3:绑定套接字并监听。

[cpp] view plaincopy
  1. SOCKADDR_IN addr;
  2. addr.sin_family=AF_INET;
  3. addr.sin_addr.S_un.S_addr=inet_addr("192.168.1.100");
  4. addr.sin_port=htons(4000);
  5. int ret=bind(m_ListenSocket,(SOCKADDR*)&addr,sizeof(addr));
  6. if(ret==INVALID_SOCKET)
  7. {
  8. return false;
  9. }
  10. ret=listen(m_ListenSocket,10);
  11. if(ret==INVALID_SOCKET)
  12. {
  13. return false;
  14. }

四：退出

[cpp] view plaincopy
  1. closesocket(m_ListenSocket);
  2. WSACleanup();

五：CClient类。

自定义类CClient类用于管理服务器接受客户端的新建套接字。在该类中实现与客户端通信。

六；管理客户端套接字链表。

当服务器接受一个客户端连接请求后就会创建一个CClient实例。将该实例地址加入链表中。

===============================================================================================================

//
/// WSAAsyncEvent模型(同步I/O模型)
///这里为什么说他是同步的，就是因为实际的数据的Copy是同步进行///的，而不是异步的，只是相应的通知机制(通知数据已经准备好了)，///是异步的
/// 和WSAAsyncSelect模型类似的是，它也允许应用程序在一个或多个套接字上，接收以事件为
/// 基础的网络事件通知。在用新模型开发的应用程序中，也能接收和处理所有那些事件。
/// 该模型最主要的差别在于网络事件会投递至一个事件对象句柄，而非投递至一个窗口例程。
/// 它的基本思想是将每个套接字都和一个WSAEVENT对象对应起来，并且在关联的时候指定需要
/// 关注的哪些网络事件。一旦在某个套接字上发生了我们关注的事件（FD_READ和FD_CLOSE），
/// 与之相关联的WSAEVENT对象被Signaled。
/// 程序定义了两个全局数组，一个套接字数组，一个WSAEVENT对象数组，其大小都是MAXIMUM_WAIT_OBJECTS（64），
/// 两个数组中的元素一一对应。
//
/// WSAEventSelect function specifies an event object to be associated with the supplied set of
/// FD_XXX network events.
//
/// 附加装置：事件监视器的集合，每一个事件监视器监视一个Socket上的相应的相应的行为
/// 微软的信箱非常畅销，购买微软信箱的人以百万计数......以至于盖茨每天24小时给客户打电话
/// ，累得腰酸背痛，喝蚁力神都不好使。微软改进了他们的信箱：在客户的家中添加一个附加装置
/// ，这个装置会监视客户的信箱，每当新的信件来临，此装置会发出“新信件到达”声，提醒老陈
/// 去收信。盖茨终于可以睡觉了。  
//

#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);
  //注意这里应该有相应的修正的地方，WSAWaitForMultipleEvents函数在fWaitAll设置成FALSE

//的时候只能指定一个事件对象受信，解决方法使用for循环进行循环检测

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

详细解析WSAAsyncSelect模型相关推荐

  1. 详细解析WSAEventSelect模型

    这个模型是一个简单的异步事件模型,使用起来比较方便,现在说一下其的具体的用法和需要注意的地方. 一,模型的例程(服务端): 先举一个王艳平网络通信上的例子: [cpp] view plaincopyp ...

  2. 详细解析SELECT模型

    先看一下下面的这句代码: int iResult = recv(s, buffer,1024); 这是用来接收数据的,在默认的阻塞模式下的套接字里,recv会阻塞在那里,直到套接字连接上有数据可读,把 ...

  3. Kaggle Titanic Challenges 生存预测 数据预处理 模型训练 交叉验证 步骤详细解析

    本博客所有内容均整理自<Hands-On Machine Learning with Scikit-Learn & TensorFlow>一书及其GitHub源码. 看<Ha ...

  4. qa职业规划_INTP职业规划模型及个案详细解析

    ISFJ ISTJ ESFJ ESTJ ISFP ISTP ESFP ESTP INTJ INTP ENTJ ENTP INFJ INFP ENFJ ENFP 欢迎各位掌管逻辑这一社会职能的各位逻辑学 ...

  5. 最新最全GPT-3模型网络结构详细解析

    最近,GPT3很火,现在有很多讲GPT-3的文章,比如讲解它可以做什么, 思考它的带来的影响, 可视化其工作方式.看了这些文章并不足以详细了解GPT-3模型,仍然需要认真研究相关论文和博客. 因此,本 ...

  6. OpenCL编程详细解析与实例

    OpenCL编程详细解析与实例 C语言与OpenCL的编程示例比较 参考链接: https://www.zhihu.com/people/wujianming_110117/posts 先以图像旋转的 ...

  7. 深度学习目标检测详细解析以及Mask R-CNN示例

    深度学习目标检测详细解析以及Mask R-CNN示例 本文详细介绍了R-CNN走到端到端模型的Faster R-CNN的进化流程,以及典型的示例算法Mask R-CNN模型.算法如何变得更快,更强! ...

  8. celery的使用(最新详细解析)

    celery的使用(最新详细解析) 一. Celery简介 Celery是一个简单.灵活且可靠的,处理大量消息的分布式系统,专注于实时处理的异步任务队列,同时也支持任务调度. Celery的架构由三部 ...

  9. AlphaCode到底强在哪儿？清华博士后十分钟视频详细解析

    来源:机器之心 本文约2300字,建议阅读5分钟 AlphaCode 到底是怎么练成的? 春节期间,DeepMind 的编程版 AlphaGo--AlphaCode 一度火到刷屏.它可以编写与普通程序 ...

最新文章

  1. Python中format_map与format字符串格式化的区别
  2. 4.1.3 文件目录
  3. java高级教程_高级Java教程
  4. (原创)SpringBoot入门
  5. 衡水计算机考试报名入口,2018下半年NCRE全国计算机等级考试报名通知
  6. python中的字符数字之间的转换函数
  7. yum安装Elasticsearch5.x
  8. JAR运行出现ClassNotFoundException异常的解决办法
  9. 100+个Java项目视频教程+源码+笔记，项目经验不用愁了！
  10. Java的PDF分页操作：分页读取、分页拆分
  11. 人工智能在医疗领域的应用
  12. 大数据 百亿级实时查询 ClickHouse SQL mysql canal kafka 数据实时同步
  13. 光大银行监控平台实践，含详细工具及架构选型思路
  14. gis热力专题图制作
  15. 最简单的深度学习入门书《动手学深度学习》
  16. 不忘初心，成于自渡——记录2020年的自己
  17. 【死磕 Spring】----- IOC 之 Factory 实例化 bean
  18. 花呗上征信，一文看懂征信所有问题
  19. 使用：EXISTS (Transact-SQL)
  20. CM10稳定版推出；CyanogenMod域名险被劫持

热门文章

  1. 通过非docker的方式进行RocketMQ的安装
  2. hello-world
  3. 数据库-数据库的备份与恢复
  4. maven工程运行环境修改
  5. 使用Java读取 “Python写入redis” 的数据踩坑记录
  6. FastDFS集群部署
  7. html2canvas截图页面中某块区域的图不全_截图操作千千万，唯舒适最重要！你更Pick谁？...
  8. php 微信机器人_微信小程序机器人自动客服功能
  9. windows环境下设置Redis自启动
  10. dsPIC30F 细节点问题不定期更新ing