服务器IO模型之Select

阻塞与非阻塞：

widows下创建套接字默认都是阻塞型的，阻塞型的好处是处理简单，理解容易，但是处理多个套接字时，就必须创建多个线程，即一个连接socket使用一个线程。而非阻塞模式比如在处理发送和接收数据时，会立即返回，不管是否有有效的数据，这就需要不断测试返回代码，来确定套接字在什么时候可读/可写，也就是确定网络事件何时发生，比如中断默认就是一种事件触发型，比如菜单按钮也是事件触发性，但是比如快递邮寄包裹，他其实使用的是一种任务制（提前规定好的）。windows也提供了众多的非阻塞I/O模型，如select、WSAAsyncSelect、WSAEventSelect、overlapped、completion
port，比如select就可以设置时间，按规定时间去查询事件是否被触发，像WSAAsyncSelect就是事件驱动型的，等，这里主要用在socket端开发服务器程序。

select模型目的：主要是避免在套接字调用上阻塞的应用程序有能力管理多个套接字，即是单一线程模式下只能处理一个套接字的问题，这样可以避免线程膨胀。

select模型函数：

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

参数说明：

nfds [in]：忽略，仅是为了兼容Berkeley套接字

readfds [in, out]：用来检查可读的套接字组合

writefds [in, out]：用来检查可写的套接字组合

exceptfds [in, out]：用来检查异常的套接字组合

timeout [in]：等待的时间, 如果为NULL，等待的时间为无穷大

返回值：select返回那些即将要被处理的socket总和，假如时间超时，将会返回SOCKET_ERROR，可以使用WSAGetLastError获得出错的原因

Select处理过程：假设以read为例，在这里windows主要是先将套接字s添加到readfds集合中，然后等待select函数返回，在select函数里面会移除没有未决的I/O操作的套接字句柄，即移除未响应的IO套接字句柄，然后看s是否认仍然还是readfs集合中，在就说明s可读了

应用程序：

CInitSock initsock;
sockaddr_in addr;
USHORT usPort = 6000;
SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP );
if (sListen == INVALID_SOCKET )
{
TRACE("create socket error:%d\n",  WSAGetLastError());
return -1;
}

addr.sin_family = AF_INET;
addr.sin_port = htons(usPort);
addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
if (::bind(sListen, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)
{
/*WSAEFAULT 10014:The system detected an invalid pointer address
in attempting to use a pointer argument in a call.*/
TRACE("bind socket error: %d\n",  WSAGetLastError());
return -1;
}
::listen(sListen, 5);

fd_set fdSocket;
FD_ZERO(&fdSocket);
FD_SET(sListen, &fdSocket);
while (true)
{
fd_set fdRead = fdSocket;
int nRet = select(0, &fdRead, NULL, NULL, NULL);
if (!nRet || nRet == SOCKET_ERROR  )
{
TRACE("select error: %d\n",  WSAGetLastError());
return -1;
}
for (unsigned int i = 0; i < fdSocket.fd_count; i++)
{
if (FD_ISSET(fdSocket.fd_array[i], &fdRead)) //这里选择了fdSocket，是因为下一次循环还要使用fdSocket
{
if (fdSocket.fd_array[i] == sListen)
{
if (fdSocket.fd_count < FD_SETSIZE)
{
sockaddr_in addrRemote;
int nAddrLen = sizeof(addrRemote);
SOCKET sNewClient = ::accept(sListen, (sockaddr*)&addrRemote, &nAddrLen);
if (sNewClient == INVALID_SOCKET )
{

TRACE("accept new client socket error: %d\n",  WSAGetLastError());
break;
}
FD_SET(sNewClient, &fdSocket);
TRACE("new client: %s\n", inet_ntoa(addrRemote.sin_addr));
}
}
else
{
char szText[256];
int nRecv = ::recv(fdSocket.fd_array[i], szText, sizeof(szText), 0);
if (!nRecv || nRecv == SOCKET_ERROR )
{
TRACE("recv data error: %d\n", WSAGetLastError());
closesocket(fdSocket.fd_array[i]);
FD_CLR(fdSocket.fd_array[i], &fdSocket);
break;
}
else
{
szText[nRecv] = '\0';
TRACE("recv data: %s", szText);
}
}
}//判断fdsocket里面的socket是否得到处理
}
}
closesocket(sListen);
sListen = INVALID_SOCKET;

return 0;

这里我使用了CInitSock， 因为在使用socket之前要加载Ws2_32.lib，这里我定义了一个类如下：

#pragma once
#include<winsock2.h>
#include <ws2tcpip.h>

#pragma comment(lib,"Ws2_32.lib")

class CInitSock
{
public:
CInitSock(BYTE minVer = 2, BYTE majVer = 2);
~CInitSock(void);
};

CInitSock::CInitSock(BYTE minVer, BYTE majVer)
{
int nResult;
WSADATA wsadata;
WORD wVerReq = MAKEWORD(minVer, majVer);
if (nResult = ::WSAStartup(wVerReq, &wsadata))
{
TRACE("WSAStartup Load DLL Failed: %d!\n", nResult);
}
}

CInitSock::~CInitSock(void)
{
/*In a multithreaded environment, WSACleanup terminates
*Windows Sockets operations for all threads.
*/
::WSACleanup();
}

默认构造函数里面有一个默认加载的版本，这里在析构函数里面将之前加载的dll资源进行释放，基础的socket服务器模型通常要进行socket创建，绑定到本地地址和端口，监听客户端的连接，一旦有客户端连接，默认会放入fdSocket中，然后将此函数加入fd_set可读的套接字集合中，select返回后，未响应的socket会被移除，即将要被处理的socket会保留下来，然后从fdSocket判断，到底是哪些socket发生了可读操作：

注意：可读操作包括有未处理的连接请求，数据可读，连接关闭/重启/中断

首先第一个判断的就是未处理的连接请求，如果有就建立新的连接通道，加入fdSocket；如果是数据可读，就读取数据；连接关闭会在下面进行测试

客户端程序：使用的是以前的一个简易客户端程序，如下

WORD wVersionRequested; //请求的版本
WSADATA wsaData;
int nErr;

//协商版本号
wVersionRequested = MAKEWORD(1,1);
nErr = WSAStartup(wVersionRequested, &wsaData);
if(nErr != 0)
{
return;
}
if( LOBYTE(wsaData.wVersion) != 1 ||
HIBYTE(wsaData.wVersion) != 1 )
{
WSACleanup();
return;
}

//创建socket端口
SOCKET sockClient = socket(AF_INET, SOCK_STREAM, 0);

SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr	= inet_addr("127.0.0.1");
addrSrv.sin_family				= AF_INET;
addrSrv.sin_port				= htons(6000);

//绑定端口号
connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

//收发数据
char recvBuf[100], sendBuf[100];
memset(recvBuf, 0, 100);
memset(sendBuf, 0, 100);

sprintf_s(sendBuf,"hello world");
send(sockClient, sendBuf, strlen(sendBuf)+1, 0);

recv(sockClient, recvBuf, 100, 0);
printf("%s\n", recvBuf);

//关闭socket通信
closesocket(sockClient);
WSACleanup();
Sleep(1000);

测试结果：
这里需要先运行服务器端，然后再开启客户端程序，服务器端会建立新的连接，并读取客户端发过来的数据然后显示出来，客户端是没有数据的，因为这里服务器端并没有发送数据，如下服务器数据：



再次开启一个客户端的效果如下：



这里并没有进行换行，两行数据在一起了，并不影响测试结果，这里还可以再强制关闭客户端后的结果，如下



这里看到error的代码为10054，我们在winerror.h里面找到如下定义：

//
// MessageId: WSAECONNRESET
//
// MessageText:
//
// An existing connection was forcibly closed by the remote host.
//
#define WSAECONNRESET                    10054L

从这里也能看出的确是强制关闭，注意服务器端里面的TRACE要给我printf才可以，TRACE默认是在调试下使用的输出语句

Select不足：其实添加到fd_set套接字数量是有限制的，winsock2.h定义的64，自定义也不超过1024，因为值太大，会对服务器的性能有影响，假设有1000个的话，在调用select之前就必须设置这1000个套接字，select返回之后，还必须检查这1000个套接字，所以开销较大。