`

socket编程的select模型

 
阅读更多
转自
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处理函数： 
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模型带来的问题了。

二、WsaAsyncSelect模型

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模型。

三、WsaEventSelect模型

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模型将解决这个问题




以下转自
http://blog.csdn.net/ganpengjin1/article/details/44678981
    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;
}
分享到：
| C++内存池的管理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    易语言Socket编程之Select模型源码

    本篇将重点讲解易语言中的Socket编程，特别是Select模型的应用。 Socket，通常被称为套接字，是网络通信的基础接口，它允许程序通过网络发送和接收数据。在易语言中，Socket编程可以用来实现客户端与服务器之间的...

    易语言Socket编程之Select模型

    本文将深入探讨易语言中的Socket编程，特别是Select模型的运用。易语言，作为一款国人开发的编程语言，以其独特的汉字编程语法，降低了编程的入门难度，使得更多初学者能够涉足编程领域。 Socket编程主要用于创建...

    易语言源码易语言Socket编程之Select模型源码.rar

    本压缩包文件"易语言Socket编程之Select模型源码.rar"提供了关于易语言中使用Select模型进行Socket编程的源代码示例。 Select模型是多路复用I/O的一种方式，广泛应用于网络编程中，特别是在处理大量并发连接时。它...

    c++实现win socket 编程中的Select I/O模型

    本文将深入探讨如何使用C++在Windows环境下实现Socket编程中的Select I/O模型。Select模型是一种经典的多路复用I/O机制，它允许单个进程同时监控多个文件描述符（包括套接字）的状态，以检测何时可以进行读写操作。 ...

    深入理解socket中的select模型

    在深入探讨socket编程时，select模型是一种常用的I/O多路复用技术，它允许程序监视多个文件描述符以查看它们是否处于可读、可写或异常状态。select模型在Unix系统中被广泛使用，是网络编程和多任务处理的重要基础。 ...

    Socket编程之Select模型.rar

    这个`Socket编程之Select模型.rar`压缩包包含了关于如何使用`select`函数进行Socket编程的易语言源码，这对于理解`select`模型的工作原理以及在实际编程中应用非常有帮助。 首先，我们需要理解`select`函数的基本...

    socket编程 使用select与线程池

    Socket编程是网络编程的基础，它提供了进程间通信的能力，特别是在分布式系统中，使得不同计算机上的程序可以相互通信。在本主题中，我们将深入探讨如何使用`select`机制和线程池来构建高效的TCP、UDP服务器，以及...

    Win32 Socket 基于Select的服务程序

    总结来说，Win32 Socket基于Select的服务程序是网络编程中一种高效且灵活的策略。Select函数允许我们监控多个Socket，以实现非阻塞I/O，优化了服务器的资源利用率，尤其在需要处理大量并发连接时显得尤为重要。在C++...

    socket server client select模型

    在IT领域，网络编程是不可或缺的一部分，而Socket编程则是实现客户端和服务器通信的基础。本教程主要探讨的是"socket server client select模型"，这是一种在多路复用I/O中常用的选择器模型，它允许程序同时监听多个...

    socket中select模型

    Socket接口提供了操作系统与网络通信的基础，而`select`模型则是多路复用IO（I/O Multiplexing）的一种实现方式，用于处理多个套接字的事件。本文将深入探讨`select`模型在socket开发中的应用和原理。 `select`函数...

    C++ select模型 异步SOCKET 聊天室服务服客户端

    首先，`select`模型是网络编程中处理多路复用I/O（Multiplexing I/O）的一种方式，允许程序同时监控多个文件描述符（包括SOCKET），等待它们准备就绪后再进行读写操作。这种方法特别适合于服务器端处理大量并发连接...

    linux下socket编程之以select方式实现并发服务器

    综上所述，`select`方式的并发服务器模型在Linux下的Socket编程中具有重要的应用价值，它允许服务器高效地处理多个并发连接，是构建网络服务的基础之一。通过分析`tcpserver.c`和`tcpclient.c`的源代码，我们可以...

    网络聊天室（socket中的select模型）

    本文将深入探讨在`socket`编程中的一种多路复用技术——`select`模型，以及如何利用它来构建一个简单的网络聊天室，类似于QQ群组。 `socket`是操作系统提供的一种接口，用于在网络上的进程间进行通信。它支持TCP...

    socket编程中select的使用

    ### Socket编程中select的使用详解 #### 一、引言 在进行网络编程时，我们经常需要处理多个连接请求，并且需要对它们的状态变化作出及时响应。为了实现这一目标，通常会采用同步I/O模型中的多路复用技术，其中`...

    socket I O模型 model 之 Select 模型例子

    总之，Select模型是网络编程中处理并发连接的一种方式，尤其适用于处理少量并发。通过理解并掌握这种模型，开发者能够编写出高效地处理网络I/O的程序。在实际工作中，根据系统特性和需求选择合适的I/O模型是至关重要...

    Socket通信(TCP)非阻塞模式-select模型

    "Socket 通信（TCP）非阻塞模式-select 模型" 本资源是关于 Socket 通信的非阻塞模式下的 Select 模型的示例代码，基于 TCP 协议，分为服务器端和客户端。该示例代码展示了如何使用 Select 模型实现非阻塞 Socket ...

    socket select io模型传文件

    在文件传输过程中，select模型能够确保在任何时候，无论是客户端还是服务器，只要有数据需要发送或接收，程序都能够及时响应。这是因为select会持续检查所有监控的socket，一旦发现有可读或可写事件，就立即唤醒等待...

    socket编程模型.doc

    本文主要探讨了在Windows环境下，Socket编程中所涉及的各种I/O模型，包括基本的Socket模型、经典的select模型以及更为高效的IOCP（I/O完成端口）模型，并简要提到了ACE和ASIO这两个跨平台的库在处理Socket I/O上的...

Magicbox
Global site tag (gtag.js) - Google Analytics