socket编程的select模型

一时失言乱红尘 2022-04-11 06:07 212阅读 0赞

转自  
\[url\]http://www.cnblogs.com/RascallySnake/archive/2013/07/11/3185071.html\[/url\]  
  
在掌握了socket相关的一些函数后，套接字编程还是比较简单的，日常工作中碰到很多的问题就是客户端/服务器模型中，如何让服务端在同一时间高效的处理多个客户端的连接，我们的处理办法可能会是在服务端不停的监听客户端的请求，有新的请求到达时，开辟一个新的线程去和该客户端进行后续处理，但是这样针对每一个客户端都需要去开辟一个新的线程，效率必定底下。  
  
其实，socket编程提供了很多的模型来处理这种情形，我们只要按照模型去实现我们的代码就可以解决这个问题。主要有select模型和重叠I/o模型，以及完成端口模型。这次，我们主要介绍下select模型，该模型又分为\[b\]\[color=red\]普通select模型\[/color\]\[/b\]，\[color=red\]\[b\]wsaasyncselect模型\[/b\]\[/color\]，\[color=red\]\[b\]wsaeventselect模型\[/b\]\[/color\]。我们将通过样例代码的方式逐一介绍。  
\[b\]  
一、select模型\[/b\]  
  
使用该模型时，在服务端我们可以开辟两个线程，一个线程用来监听客户端的连接  
  
请求，另一个用来处理客户端的请求。主要用到的函数为select函数。如：

全局变量：
    fd_set  g_fdClientSock;

线程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);
    
        int clientNum = 0;
    
        sockaddr_in clientAddr;
    
        int nameLen = sizeof( clientAddr );
    
        while( clientNum < FD_SETSIZE )
        {
       
            SOCKET clientSock = accept( listenSock, (sockaddr*)&clientAddr, &nameLen );
            FD_SET( clientSock, &g_fdClientSock);
            clientNum++;
         }

线程2处理函数：

fd_set fdRead;
        FD_ZERO( &fdRead );
        int nRet = 0;
        char* recvBuffer =(char*)malloc( sizeof(char) * 1024 );
    
        if ( recvBuffer == NULL )
        {
       
            return;
        }
    
        memset( recvBuffer, 0, sizeof(char) * 1024 );
        while ( true )
        {
       
            fdRead = g_fdClientSock;
            nRet = select( 0, &fdRead, NULL, NULL, NULL );
            if ( nRet != SOCKET_ERROR )
            {
       
                for ( int i = 0; i < g_fdClientSock.fd_count; i++ )
                {
       
                    if ( FD_ISSET(g_fdClientSock.fd_array[i],&fdRead)  )
                    {
       
                        memset( recvBuffer, 0, sizeof(char) * 1024 );
                        nRet = recv( g_fdClientSock.fd_array[i], recvBuffer, 1024, 0);
                        if ( nRet == SOCKET_ERROR )
                        {
       
                            closesocket( g_fdClientSock.fd_array[i] )；
                                FD_CLR( g_fdClientSock.fd_array[i], &g_fdClientSock );
                        }
                        else
                        {
       
                            //todo:后续处理
                           }
                    }
                }
            }
        }
    
        if ( recvBuffer != NULL )
        {
       
            free( recvBuffer );
        }

该模型有个最大的缺点就是，它需要一个死循环不停的去遍历所有的客户端套接字集合，询问是否有数据到来，这样，如果连接的客户端很多，势必会影响处理客户端请求的效率，但它的优点就是解决了每一个客户端都去开辟新的线程与其通信的问题。如果有一个模型，可以不用去轮询客户端套接字集合，而是等待系统通知，当有客户端数据到来时，系统自动的通知我们的程序，这就解决了select模型带来的问题了。  
  
\[b\]二、WsaAsyncSelect模型\[/b\]  
  
WsaAsyncSelect模型就是这样一个解决了普通select模型问题的socket编程模型。它是在有客户端数据到来时，系统发送消息给我们的程序，我们的程序只要定义好消息的处理方法就可以了，用到的函数只要是WSAAsyncSelect,如：  
  
首先，我们定义一个Windows消息，告诉系统，当有客户端数据到来时，发送该消息给我们。

#define  UM_SOCK_ASYNCRECVMSG  WM_USER + 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);
    
        int clientNum = 0;
        sockaddr_in clientAddr;
        int nameLen = sizeof( clientAddr );
    
        while( clientNum < FD_SETSIZE )
        {
       
            SOCKET clientSock = accept( listenSock, (sockaddr*)&clientAddr, &nameLen );
            //hWnd为接收系统发送的消息的窗口句柄
             WSAAsyncSelect( clientSock, hWnd, UM_SOCK_ASYNCRECVMSG, FD_READ | FD_CLOSE );
            clientNum++;
        }

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

SOCKET clientSock = (SOCKET)wParam;
       if ( WSAGETSELECTERROR( lParam ) )
       {
       
          closesocket( clientSock );
          return;
       }
    
       switch ( WSAGETSELECTEVENT( lParam ) )
       {
       
           case FD_READ:
           {
       
               char recvBuffer[1024] = {'\0'};
               int nRet = recv( clientSock, recvBuffer, 1024, 0 );
               if ( nRet > 0 )
               {
       
                    szRecvMsg.AppendFormat(_T("Client %d Say:%s\r\n"), clientSock, recvBuffer );
               }
               else
               {
       
                    //client disconnect
                    szRecvMsg.AppendFormat(_T("Client %d Disconnect!\r\n"), clientSock );
               }
            }                              
    
            break;
    
          case FD_CLOSE:
          {
       
               closesocket( clientSock );
               szRecvMsg.AppendFormat(_T("Client %d Disconnect!\r\n"), clientSock );
          }
    
          break;
        }

可以看到WsaAsyncSelect模型是非常简单的模型，它解决了普通select模型的问题，但是它最大的缺点就是它只能用在windows程序上，因为它需要一个接收系统消息的窗口句柄，那么有没有一个模型既可以解决select模型的问题，又不限定只能是windows程序才能用呢？下面我们来看看WsaEventSelect模型。  
  
\[b\]三、WsaEventSelect模型\[/b\]  
  
WsaEventSelect模型是一个不用主动去轮询所有客户端套接字是否有数据到来的模型，它也是在客户端有数据到来时，系统发送通知给我们的程序，但是，它不是发送消息，而是通过事件的方式来通知我们的程序，这就解决了WsaAsyncSelect模型只能用在windows程序的问题。  
  
该模型的实现，我们也可以开辟两个线程来进行处理，一个用来接收客户端的连接请求，一个用来与客户端进行通信，用到的主要函数有WSAEventSelect，WSAWaitForMultipleEvents，WSAEnumNetworkEvents实现方式如下：  
  
首先定义三个全局数组

SOCKET      g_SockArray[MAX_NUM_SOCKET];//存放客户端套接字
    
    WSAEVENT    g_EventArray[MAX_NUM_SOCKET];//存放该客户端有数据到来时，触发的事件
    
    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模型将解决这个问题  
  
  
以下转自  
\[url\]http://blog.csdn.net/ganpengjin1/article/details/44678981\[/url\]  
windows提供了选择(select)、异步选择(WSAAsyncSelect)、事件选择(WSAEventSelect)、重叠I /O(overlapped I/O)和完成端口(completion port)。  
客户端：

#include <winsock2.h>
    #include <iostream>
    
    #pragma comment(lib, "WS2_32.lib")
    const unsigned int PORT = 11024;
    const int kBufferSize    = 1024;
    
    int main() {
       
    	WSADATA wsData;
    	int iResult = WSAStartup(MAKEWORD(2, 2), &wsData);
    	if(iResult != NO_ERROR) {
       
    		std::cout << "start up failed" << std::endl;
    		return -1;
    	}
    
    	SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //set tcp 
    	if(s == INVALID_SOCKET) {
       
    		std::cout << "Error socket" << std::endl;
    		WSACleanup();
    		return -1;
    	}
    
    	SOCKADDR_IN addIn;
    	addIn.sin_port = htons(PORT);
    	addIn.sin_family = AF_INET;
    	addIn.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    	//-----------------------------------
    	int iMode = 1;
    	ioctlsocket(s, FIONBIO, (u_long FAR *)&iMode); // set the mode is the unblock
    	connect(s, (LPSOCKADDR)&addIn, sizeof(addIn));
    
    	char cSendBuffer[kBufferSize];
    	std::cout << "Tell the Server: ";
    	std::cin >> cSendBuffer;
    	int iSendRet = send(s, cSendBuffer, kBufferSize, 0);
    	char cRecnBuffer[kBufferSize] = "";
    	int iRecvRet = 0;
    
    	while(true)
    	{
       
    		if ((iRecvRet = recv(s, cRecnBuffer, kBufferSize, 0)) > 0)
    		{
       
    			std::cout << "recvive information from server: " << cRecnBuffer << std::endl;
    			std::cout << "Tell the Server: ";
    			std::cin >> cSendBuffer;
    			send(s, cSendBuffer, kBufferSize, 0);
    		}
    	}
    	closesocket(s);
    	WSACleanup();
    	return 0;
    }

服务端：

#include <iostream>
    #include <winsock2.h>
    
    #pragma comment(lib, "WS2_32.lib")
    
    const unsigned int PORT = 11024;
    const int kBufferSize	= 1024;
    int g_ClientCount = 0;
    SOCKET g_ClientSocket[FD_SETSIZE];
    unsigned long  WINAPI WorkerThread(void *p);
    
    int main() {
       
    	WSADATA wsaData;
    	if(WSAStartup(2, &wsaData) != 0) {
       
    		std::cout << "start up failed" << std::endl;
    		return -1;
    	}
    
    	SOCKET sev = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
    	if(sev == SOCKET_ERROR) {
       
    		std::cout << "create the socket failed" << std::endl;
    		return -1;
    	}
    
    	SOCKADDR_IN addIn;
    	addIn.sin_port = htons(PORT);
    	addIn.sin_family = AF_INET;
    	addIn.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    	int ibRet = bind(sev, (LPSOCKADDR)&addIn, sizeof(addIn));
    	if(ibRet != 0) {
       
    		std::cout << "bind failed" << std::endl;
    		return -1;
    	}
    
    	int iLRet = listen(sev, 10);
    	if(iLRet != 0) {
       
    		std::cout << "Listen failed " << std::endl;
    		return -1;
    	}
    
    	SOCKET acceptSocket;
    	int iLen = sizeof(addIn);
    	unsigned long arg = 1;
    	ioctlsocket(sev, FIONBIO, &arg);
    
    	HANDLE threadHandle = CreateThread(NULL, 0, WorkerThread, NULL, 0, 0);   
    	while(true) {
       
    		acceptSocket = accept(sev, (LPSOCKADDR)&addIn, &iLen);
    		if(acceptSocket != SOCKET_ERROR) {
       
    			g_ClientSocket[g_ClientCount++] = acceptSocket;
    		}
    	}
    
    	for(int i = 0; i < g_ClientCount; ++i) {
       
    		closesocket(g_ClientSocket[i]); //clear the socket connect
    	}
    	CloseHandle(threadHandle); // close the thread
    	return 0;
    }
    
    unsigned long  WINAPI WorkerThread(void *p) {
       
    	FD_SET read;
    	timeval limitTime = {1, 0};
    	char Message[kBufferSize];
    	Message[0] = '\0';
    	while(true) {
       
    		FD_ZERO(&read);
    		for(int i = 0; i < g_ClientCount; ++i) {
       
    			FD_SET(g_ClientSocket[i], &read);
    		}
    
    		int iRet = select(0, &read, NULL, NULL, &limitTime); 
    		if(iRet == 0) {// time out
    			continue;
    		}
    
    		for(int i = 0; i < g_ClientCount; ++i) {
       
    			if(FD_ISSET(g_ClientSocket[i], &read)) {
       
    				int iRecv = recv(g_ClientSocket[i], Message, kBufferSize, 0);
    				if(iRecv == 0 || (iRecv == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET)) {
       
    					closesocket(g_ClientSocket[i]);
    					//after the current socket that will go befor one step
    					g_ClientSocket[i--] = g_ClientSocket[--g_ClientCount]; //  the total will decrease;
    
    				} else {
       
    					if(iRecv > 0) {
       
    						std::cout << "Server Receive the data is: " << Message << std::endl;
    						std::cout << "Input the send Message:　";
    						std::cin >> Message;
    						send(g_ClientSocket[i], Message, kBufferSize, 0);
    					}
    				}
    			}
    		}
    	}
    	return  0;
    }