Windows网络编程之Select模型学习笔记

关于select模型的理论讲解，网上随便一搜就有很多大神的精彩文章，这里就不重复造轮子了。不过要真正理解select模型，代码才是最好的文章。我在网上看了好多代码，可能是相互转载的原因，有些代码不是编译不过，就是逻辑不通，有些虽然可以正常运行，但是会导致CPU暴涨，还有个别大神只给出了关键代码，这对于我等新手菜鸟来说，简直苦不堪言。没办法了，自己动手，丰衣足食，先看一下下面的这行代码：

SOCKET clientSocket = accept(socketListen, (sockaddr*)&clientAddr, &len);

哈哈，能看到这篇文章的人肯定都知道，这是服务器用来等待客户端连接请求的，在默认的阻塞模式下的socket编程里，accept会一直阻塞在那里，直到有新的客户端连接请求到来，accept函数才会返回。在单线程的程序里出现这种情况一般是无法容忍的，因为如果永远都没有新的连接请求过来，那么整个程序就会一直被卡死在这里。很多人也许会想到可以用多线程来解决这个问题，那么我们再看下面的代码：

result = recv(socket, bufRecv, 1024, 0);

这是用来接收数据的，在默认的阻塞模式下，如果套接字连接上没有数据到来的话，recv同样会一直阻塞在那里。假设这是服务器上用来接收客户端数据的代码，在有多个客户端连接到服务器的情况下，我们要为每个客户端都分别创建一个线程来调用recv，否则一旦某个客户端的数据接收出现了阻塞，就会导致其他客户端的数据全部无法正常处理。当客户端有成百上千的时候，哈哈，你还敢使用多线程来解决这个问题吗？于是又有人会想到，既然socket编程默认是阻塞模式的，那么将其设置为非阻塞模式是不是也可以解决这个问题呢？我们还是用代码来试试吧：

u_long mode = 1;
ioctlsocket(socket, FIONBIO, &mode);///设置非阻塞模式
result = recv(socket, bufRecv, 1024, 0);

设置非阻塞模式之后可以发现，不管套接字连接上有没有数据到来，recv的调用都会马上返回。不过在没有数据到来的情况下，recv虽然返回了，但是调用WSAGetLastError()你就会得到一个错误码：WSAEWOULDBLOCK，意思是请求的操作没有成功完成。所以为了能够完整地接收数据，就需要不断地循环调用recv并判断WSAGetLastError()返回值，直到成功为止。同样的，当客户端有成百上千的时候，程序的运行效率和资源开销将会变得让人崩溃……

为了解决上述问题，Winsock提供了五种I/O模型：select，WSAAsyncSelect，WSAEventSelect，Overlapped，Completion。下面是一个完整的基于TCP协议的socket编程，分为服务端和客户端，其中的服务器实现就使用了select模型。这只是一个入门级别的代码，比较适合在网络编程方面跟我水平一样的小伙伴，哈哈……

TCP服务端代码：

#include <WS2tcpip.h>
#include <WinSock2.H>
#include <iostream>

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

int main()
{
/// 初始化socket
WSADATA wsaData;
WORD version = MAKEWORD(2,2);
int result = 0;
result = WSAStartup(version, &wsaData);
if (result != 0)
{
std::cout << "WSAStartup() error." << std::endl;
return -1;
}

/// 创建socket
SOCKET socketListen;
socketListen = socket(AF_INET, SOCK_STREAM, 0);
if (socketListen == INVALID_SOCKET)
{
WSACleanup();
std::cout << "socket() error." << std::endl;
return -1;
}

/// 服务器地址结构
sockaddr_in svrAddress;
svrAddress.sin_family = AF_INET;
svrAddress.sin_addr.s_addr = INADDR_ANY;
svrAddress.sin_port = htons(8000);

/// 绑定服务器套接字
result = bind(socketListen, (sockaddr*)&svrAddress, sizeof(svrAddress));
if (result == SOCKET_ERROR)
{
closesocket(socketListen);
WSACleanup();
std::cout << "bind() error." << std::endl;
return -1;
}

/// 开启监听
result = listen(socketListen, 5);
if (result == SOCKET_ERROR)
{
closesocket(socketListen);
WSACleanup();
std::cout << "listen() error." << std::endl;
return -1;
}
std::cout << "服务器启动成功，监听端口：" << ntohs(svrAddress.sin_port) << std::endl;

/// select模型
fd_set allSockSet;
FD_ZERO(&allSockSet);

FD_SET(socketListen, &allSockSet); // 将socketListen加入套接字集合中

while (true)
{
fd_set readSet;
FD_ZERO(&readSet);
readSet = allSockSet;

result = select(0, &readSet, NULL, NULL, NULL);
if (result == SOCKET_ERROR)
{
std::cout << "listen() error." << std::endl;
break;
}

if (FD_ISSET(socketListen, &readSet))
{
sockaddr_in clientAddr;
int len = sizeof(clientAddr);

SOCKET clientSocket = accept(socketListen, (sockaddr*)&clientAddr, &len);
if (clientSocket == INVALID_SOCKET)
{
std::cout << "accept() error." << std::endl;
break;
}
FD_SET(clientSocket, &allSockSet);	 /// 将新创建的套接字加入到集合中

char ipAddress[16] = { 0 };
inet_ntop(AF_INET, &clientAddr, ipAddress, 16);
std::cout << "有新的连接[" << ipAddress << ":" << ntohs(clientAddr.sin_port)
<< "], 目前客户端的数量为：" << allSockSet.fd_count - 1 << std::endl;

continue;
}

for (u_int i = 0; i < allSockSet.fd_count; ++i)
{
SOCKET socket = allSockSet.fd_array[i];

sockaddr_in clientAddr;
int len = sizeof(clientAddr);
getpeername(socket, (struct sockaddr *)&clientAddr, &len);
char ipAddress[16] = { 0 };
inet_ntop(AF_INET, &clientAddr, ipAddress, 16);

/// 可读性监视，可读性指有连接到来、有数据到来、连接已关闭、重置或终止
if (FD_ISSET(socket, &readSet))
{
char bufRecv[100];
result = recv(socket, bufRecv, 100, 0);
if (result == SOCKET_ERROR)
{
DWORD err = WSAGetLastError();
if (err == WSAECONNRESET)		/// 客户端的socket没有被正常关闭,即没有调用closesocket
{
std::cout << "客户端[" << ipAddress << ":" << ntohs(clientAddr.sin_port) << "]被强行关闭, ";
}
else
{
std::cout << "recv() error，" << std::endl;
}

closesocket(socket);
FD_CLR(socket, &allSockSet);

std::cout << "目前客户端的数量为：" << allSockSet.fd_count - 1 << std::endl;
break;
}
else if (result == 0)				/// 客户端的socket调用closesocket正常关闭
{
closesocket(socket);
FD_CLR(socket, &allSockSet);

std::cout << "客户端[" << ipAddress << ":" << ntohs(clientAddr.sin_port)
<< "]已经退出，目前客户端的数量为：" << allSockSet.fd_count - 1 << std::endl;
break;
}

bufRecv[result] = '\0';
std::cout << "来自客户端[" << ipAddress << ":" << ntohs(clientAddr.sin_port)
<< "]的消息：" << bufRecv << std::endl;
}
}
}

for (u_int i = 0; i < allSockSet.fd_count; ++i)
{
SOCKET socket = allSockSet.fd_array[i];
closesocket(socket);
}

WSACleanup();
return 0;
}

在服务器的代码中，最好把监听的socket套接字也添加到select模型的套接字集合中，再通过判断具备可读性的套接字是否是监听的socket套接字来调用accept处理客户端的连接请求。网上有些示例代码就是没有这么做，而是只把客户端连接服务器的socket套接字放到select模型的套接字集合中，然后在创建一个线程循环调用select监视客户端socket套接字的可读性。采用这种方式的话，一旦始终都没有客户端连接到服务器，线程里的select就是在监视一个空的套接字集合，select会马上返回，再次重新循环，如此往复，线程就变成了一个死循环，CPU利用率肯定瞬间暴涨。

TCP客户端代码：

#include <iostream>
#include <WS2tcpip.h>
#include <WinSock2.H>

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

#define SERVER_ADDRESS		"127.0.0.1"
#define SERVER_PORT			8000

#define SOCKET_NUM			1		/// 客户端socket的个数,修改该值可以改变连接到服务器的客户端个数

int main()
{
WORD wVersionRequested = MAKEWORD(2, 2);
WSADATA wsaData;
int err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) return 1;

if (LOBYTE(wsaData.wVersion) != 2 ||
HIBYTE(wsaData.wVersion) != 2)
{
WSACleanup();
std::cout << "WSAStartup() error." << std::endl;
return -1;
}

SOCKET allSocketClients[SOCKET_NUM];
for (int i = 0; i < SOCKET_NUM; i ++)
{
SOCKET socketClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (socketClient == INVALID_SOCKET)
{
WSACleanup();
std::cout << "socket() error." << std::endl;
return -1;
}
allSocketClients[i] = socketClient;
}

SOCKADDR_IN server;
memset(&server, 0, sizeof(SOCKADDR_IN));
server.sin_family = AF_INET;
server.sin_port = htons(SERVER_PORT);
inet_pton(server.sin_family, SERVER_ADDRESS, &server.sin_addr);

for (int i = 0; i < SOCKET_NUM; i++)
{
SOCKET socketClient = allSocketClients[i];
err = connect(socketClient, (struct sockaddr *)&server, sizeof(SOCKADDR_IN));
if (err == SOCKET_ERROR)
{
std::cout << "connect() error." << std::endl;
closesocket(socketClient);
WSACleanup();
return -1;
}

std::cout << "第 " << i + 1 << " 个客户端连接服务器成功。" << std::endl;
}

for (int i = 0; i < SOCKET_NUM; i++)
{
SOCKET socketClient = allSocketClients[i];
char message[100] = { 0 };
sprintf_s(message, "我是第 %d 个客户端 ", i + 1);
send(socketClient, message, strlen(message), 0);
}

/// 按 q 退出程序
do
{
} while (getchar() != 'q');

for (int i = 0; i < SOCKET_NUM; i++)
{
SOCKET socketClient = allSocketClients[i];
closesocket(socketClient);
}

WSACleanup();

return 0;
}

输出结果：



在Winsock编程中使用select模型时，受限于轮询的套接字数量，这个数量由头文件WinSock2.h中定义FD_SETSIZE值来表示，默认值是64，所以上述客户端代码开启的socket个数不能超过64个。但事实上这个算不上真的限制，有很多方法可以解除这个限制，详情请自行搜索“突破select模型的FD_SETSIZE限制”。

提示：以上代码在Visual Studio 2013编译通过。