socket之 select模型

     前段时间一直想学习网络编程的select模型，看了《windows网络编程》的介绍，参考了别人的博客。

  这里的资料主要来自http://www.cnblogs.com/RascallySnake/archive/2013/07/11/3185071.html ，感谢博主的无私奉献。

    在掌握了socket相关的一些函数后，套接字编程还是比较简单的，日常工作中碰到很多的问题就是客户端/服务器模型中，如何让服务端在同一时间高效的处理多个客户端的连接，我们的处理办法可能会是在服务端不停的监听客户端的请求，有新的请求到达时，开辟一个新的线程去和该客户端进行后续处理，但是这样针对每一个客户端都需要去开辟一个新的线程，效率必定底下。

     其实，socket编程提供了很多的模型来处理这种情形，我们只要按照模型去实现我们的代码就可以解决这个问题。主要有select模型和重叠I/o模型，以及完成端口模型。这次，我们主要介绍下select模型，该模型又分为普通select模型，wsaasyncselect模型，wsaeventselect模型。我们将通过样例代码的方式逐一介绍。

一、select模型

使用该模型时，在服务端我们可以开辟两个线程，一个线程用来监听客户端的连接

请求，另一个用来处理客户端的请求。主要用到的函数为select函数。如：

全局变量：

fd_set  g_fdClientSock;

线程1处理函数：

 1  SOCKET listenSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
 2 
 3     sockaddr_in sin;
 4     sin.sin_family = AF_INET;
 5     sin.sin_port = htons(7788);
 6     sin.sin_addr.S_un.S_addr = INADDR_ANY;
 7 
 8     int nRet = bind( listenSock, (sockaddr*)&sin, (int)(sizeof(sin)));
 9     if ( nRet == SOCKET_ERROR )
10     {
11         DWORD errCode = GetLastError();
12         return;
13     }
14 
15     listen( listenSock, 5);
16 
17     int clientNum = 0;
18 
19     sockaddr_in clientAddr;
20 
21     int nameLen = sizeof( clientAddr );
22 
23     while( clientNum < FD_SETSIZE )
24     {
25         SOCKET clientSock = accept( listenSock, (sockaddr*)&clientAddr, &nameLen );
26         FD_SET( clientSock, &g_fdClientSock);
27         clientNum++;
28      }

线程2处理函数：

 1 fd_set fdRead;
 2     FD_ZERO( &fdRead );
 3     int nRet = 0;
 4     char* recvBuffer =(char*)malloc( sizeof(char) * 1024 );
 5 
 6     if ( recvBuffer == NULL )
 7     {
 8         return;
 9     }
10 
11     memset( recvBuffer, 0, sizeof(char) * 1024 );
12     while ( true )
13     {
14         fdRead = g_fdClientSock;
15        //选出有符合消息的集合
16         nRet = select( 0, &fdRead, NULL, NULL, NULL );
17         if ( nRet != SOCKET_ERROR )
18         {
19             for ( int i = 0; i < g_fdClientSock.fd_count; i++ )
20             {
21               //判断某个客户端是否在有消息的集合内
22                 if ( FD_ISSET(g_fdClientSock.fd_array[i],&fdRead)  )
23                 {
24                     memset( recvBuffer, 0, sizeof(char) * 1024 );
25                     nRet = recv( g_fdClientSock.fd_array[i], recvBuffer, 1024, 0);
26                     if ( nRet == SOCKET_ERROR )
27                     {
28                         closesocket( g_fdClientSock.fd_array[i] )；
29                             FD_CLR( g_fdClientSock.fd_array[i], &g_fdClientSock );
30                     }
31                     else
32                     {
33                         //todo:后续处理
34                        }
35                 }
36             }
37         }
38     }
39 
40     if ( recvBuffer != NULL )
41     {
42         free( recvBuffer );
43     }

该模型有个最大的缺点就是，它需要一个死循环不停的去遍历所有的客户端套接字集合，询问是否有数据到来，这样，如果连接的客户端很多，势必会影响处理客户端请求的效率，但它的优点就是解决了每一个客户端都去开辟新的线程与其通信的问题。如果有一个模型，可以不用去轮询客户端套接字集合，而是等待系统通知，当有客户端数据到来时，系统自动的通知我们的程序，这就解决了select模型带来的问题了。

二、WsaAsyncSelect模型

WsaAsyncSelect模型就是这样一个解决了普通select模型问题的socket编程模型。它是在有客户端数据到来时，系统发送消息给我们的程序，我们的程序只要定义好消息的处理方法就可以了，用到的函数只要是WSAAsyncSelect,如：

首先，我们定义一个Windows消息，告诉系统，当有客户端数据到来时，发送该消息给我们。

#define  UM_SOCK_ASYNCRECVMSG  WM_USER + 1

在我们的处理函数中可以如下监听客户端的连接：

 1   SOCKET listenSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
 2     sockaddr_in sin;
 3     sin.sin_family = AF_INET;
 4     sin.sin_port = htons(7788);
 5     sin.sin_addr.S_un.S_addr = INADDR_ANY;
 6     int nRet = bind( listenSock, (sockaddr*)&sin, (int)(sizeof(sin)));
 7     if ( nRet == SOCKET_ERROR )
 8     {
 9         DWORD errCode = GetLastError();
10         return;
11     }
12 
13     listen( listenSock, 5);
14 
15     int clientNum = 0;
16     sockaddr_in clientAddr;
17     int nameLen = sizeof( clientAddr );
18 
19     while( clientNum < FD_SETSIZE )
20     {
21         SOCKET clientSock = accept( listenSock, (sockaddr*)&clientAddr, &nameLen );
22         //hWnd为接收系统发送的消息的窗口句柄
23          WSAAsyncSelect( clientSock, hWnd, UM_SOCK_ASYNCRECVMSG, FD_READ | FD_CLOSE );
24         clientNum++;
25     }
26

接下来，我们需要在我们的窗口添加对UM_SOCK_ASYNCRECVMSG消息的处理函数，在该函数中真正接收客户端发送过来的数据，在这个消息处理函数中的wparam参数表示的是客户端套接字，lparam参数表示的是发生的网络事件如：

 1  SOCKET clientSock = (SOCKET)wParam;
 2    if ( WSAGETSELECTERROR( lParam ) )
 3    {
 4       closesocket( clientSock );
 5       return;
 6    }
 7 
 8    switch ( WSAGETSELECTEVENT( lParam ) )
 9    {
10        case FD_READ:
11        {
12            char recvBuffer[1024] = {''};
13            int nRet = recv( clientSock, recvBuffer, 1024, 0 );
14            if ( nRet > 0 )
15            {
16                 szRecvMsg.AppendFormat(_T("Client %d Say:%s
"), clientSock, recvBuffer );
17            }
18            else
19            {
20                 //client disconnect
21                 szRecvMsg.AppendFormat(_T("Client %d Disconnect!
"), clientSock );
22            }
23         }                              
24 
25         break;
26 
27       case FD_CLOSE:
28       {
29            closesocket( clientSock );
30            szRecvMsg.AppendFormat(_T("Client %d Disconnect!
"), clientSock );
31       }
32 
33       break;
34     }
35

可以看到WsaAsyncSelect模型是非常简单的模型，它解决了普通select模型的问题，但是它最大的缺点就是它只能用在windows程序上，因为它需要一个接收系统消息的窗口句柄，那么有没有一个模型既可以解决select模型的问题，又不限定只能是windows程序才能用呢？下面我们来看看WsaEventSelect模型。

三、WsaEventSelect模型

WsaEventSelect模型是一个不用主动去轮询所有客户端套接字是否有数据到来的模型，它也是在客户端有数据到来时，系统发送通知给我们的程序，但是，它不是发送消息，而是通过事件的方式来通知我们的程序，这就解决了WsaAsyncSelect模型只能用在windows程序的问题。

该模型的实现，我们也可以开辟两个线程来进行处理，一个用来接收客户端的连接请求，一个用来与客户端进行通信，用到的主要函数有WSAEventSelect，WSAWaitForMultipleEvents，WSAEnumNetworkEvents实现方式如下：

首先定义三个全局数组

1 SOCKET      g_SockArray[MAX_NUM_SOCKET];//存放客户端套接字
2 
3 WSAEVENT    g_EventArray[MAX_NUM_SOCKET];//存放该客户端有数据到来时，触发的事件
4 
5 UINT32      g_totalEvent = 0;//记录客户端的连接数
线程1处理函数如下：
SOCKET listenSock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
    sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(7788);
    sin.sin_addr.S_un.S_addr = INADDR_ANY;
    int nRet = bind( listenSock, (sockaddr*)&sin, (int)(sizeof(sin)));
    if ( nRet == SOCKET_ERROR )
    {
        DWORD errCode = GetLastError();
        return；
    }

    listen( listenSock, 5);

    sockaddr_in clientAddr;
    int nameLen = sizeof( clientAddr );
    while( g_totalEvent < MAX_NUM_SOCKET )
    {
        SOCKET clientSock = accept( listenSock, (sockaddr*)&clientAddr, &nameLen );
        if ( clientSock == INVALID_SOCKET )
        {
            continue;
        }
        g_SockArray[g_totalEvent] = clientSock;

        if( (g_EventArray[g_totalEvent] = WSACreateEvent()) == WSA_INVALID_EVENT )
        {
            continue;
        }
       //将套接字和事件内核对象绑定在一起
        WSAEventSelect( clientSock, g_EventArray[g_totalEvent],FD_READ | FD_CLOSE );
        g_totalEvent++;
    }



 线程2的处理函数如下：






 int nIndex = 0;
    char* recvBuffer =(char*)malloc( sizeof(char) * 1024 );

    if ( recvBuffer == NULL )
    {
　　　　return;
    }

    memset( recvBuffer, 0, sizeof(char) * 1024 );

    while( true )
    {
      //等待内核对象被触发
        nIndex = WSAWaitForMultipleEvents( g_totalEvent, g_EventArray, FALSE, WSA_INFINITE,FALSE );
        if ( nIndex == WSA_WAIT_FAILED )
        {
            continue;
        }
        else
        { 
    //手动重置内核对象为未触发状态
            WSAResetEvent( g_EventArray[ nIndex - WSA_WAIT_EVENT_0]);
            SOCKET clientSock = g_SockArray[ nIndex - WSA_WAIT_EVENT_0 ];
            WSANETWORKEVENTS wsaNetWorkEvent;
          //确定是哪种类型的网络消息
 int nRet = WSAEnumNetworkEvents( clientSock, g_EventArray[nIndex - WSA_WAIT_EVENT_0], &wsaNetWorkEvent );
            if ( SOCKET_ERROR == nRet )
            {
                continue;
            }
            else if ( wsaNetWorkEvent.lNetworkEvents & FD_READ )
            {
                if ( wsaNetWorkEvent.iErrorCode[FD_READ_BIT] != 0 )
                {
                    //occur error
                    closesocket( clientSock );
                }
                else 
                {
                    memset( recvBuffer, 0, sizeof(char) * 1024 );
                    nRet = recv( clientSock, recvBuffer, 1024, 0);
                    if ( nRet == SOCKET_ERROR )
                    {
                        closesocket( clientSock );
                    }
                    else
                    {
                        //todo:对接收到的客户端数据进行处理
                        }
                 }
             }
             else if( wsaNetWorkEvent.lNetworkEvents & FD_CLOSE )
             {
                if ( wsaNetWorkEvent.iErrorCode[FD_CLOSE_BIT] != 0 )
                {
                    //occur error
                    closesocket( clientSock );
                }
                else
                {
                    closesocket( clientSock );
                }  
               //记得移除已经关闭的客户端
             }
        }
    }

    if ( recvBuffer != NULL )
    {
        free( recvBuffer );
    }





 该模型通过一个死循环里面调用WSAWaitForMultipleEvents函数来等待客户端套接字对应的Event的到来，一旦事件通知到达，就通过该套接字去接收数据。虽然WsaEventSelect模型的实现较前两种方法复杂，但它在效率和兼容性方面是最好的。


    以上三种模型虽然在效率方面有了不少的提升，但它们都存在一个问题，就是都预设了只能接收64个客户端连接，虽然我们在实现时可以不受这个限制，但是那样，它们所带来的效率提升又将打折扣，那又有没有什么模型可以解决这个问题呢？我们的下一篇重叠I/0模型将解决这个问题



 









        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/yfyzy/p/4017825.html