三-select模型

合集 - Win Socket套接字编程(3)

1.二：简单的C/S阻塞模型2023-12-012.一：启动（关闭）套接字2023-10-14

3.三-select模型2023-12-05

收起

select模型是对简单C/S模型的优化，他解决了accept函数阻塞等待连接的问题。并且允许应用程序同时监视多个套接字，从而实现简单的并发请求。通过调用select函数确认一个或多个套接字当前的状态，并根据当前状态进行相应操作。在select模型模型中，select函数是最关键的。

select模型工作原理

select模型维护了一个Socket数组，通过遍历该数组检查当前是否存在就绪socket，并将所有就绪的socket返回。我们遍历该数组提供相应服务。工作原理大致如下：

1. 将服务端Socket添加至socket数组中。
2. 调用select()函数遍历socket数组。
3. 返回就绪socket数组，对该数组集中处理。
4. 如果是服务端Socket，调用accept()函数接收连接请求，并将该客户端数组添加至socket数组。
5. 如果是客户端Socket，调用send()、recv()函数进行通信，当客户端下线时，从socket数组中移除该Socket。
6. 重复执行2-6步。

select模型使用步骤

1. 启动Socket服务
2. 创建套接字
3. 为套接字绑定端口信息
4. 监听套接字
5. 使用select模型监听套接字集合，处理数据
6. 关闭套接字和网络服务

select()函数

该函数定义如下：

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

参数

• nfds：忽略，传入0。为了与Berkeley 套接字兼容。
• readfds：可读取套接字的集合，调用函数时传入要监视的套接字，函数返回时保存可读套接字。
• writefds：可写套接字的集合。只要建立连接，则任何时候都可写入，可以传NULL。
• exceptfds：异常套接字集合。
• timeout：指定超时时间。

如果是服务端socket套接字，可读表示当前有客户端进行连接。如果是客户端套接字，可读表示当前有数据发送至服务端。select()函数是一个阻塞函数，如果指定了超时时间且没有socket就绪，select()函数返回。

返回值

• 0：超时
• >0：当前就绪的套接字数量，就绪的套接字保存在readfds中。
• -1：出现错误，可以通过WSAGetLasterror()函数获取错误码。

fd_set结构体

fd_set结构体定义如下：

typedef struct fd_set {
        u_int   fd_count;               //fd_array数组中当前元素个数
        SOCKET  fd_array[FD_SETSIZE];   //socket数组
} fd_set;

在给select函数传递参数时，我们将需要监听的socket封装进fd_set结构体。select函数会顺序遍历数组，当发现有socket就绪，select函数返回，就绪的socket集合通常保存在readfds中。

下面列出了几个关于fd_set结构体的操作宏：

示例

#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include <iostream>
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib")
using namespace std;
const int nMajorVersion = 2;
const int nMinorVersion = 2;

int main()
{
    DWORD dwVersion = MAKEWORD(nMajorVersion, nMinorVersion);
    WSADATA wsaData;
    int nStartRet = WSAStartup(dwVersion, &wsaData);
    if (nStartRet != 0)
    {
        cout << "WSAStartup failed with error :" << nStartRet << endl;
        return 1;
    }

    if (LOBYTE(wsaData.wVersion) != nMajorVersion || HIBYTE(wsaData.wVersion) != nMinorVersion)
    {
        cout << "version failed" << endl;
        WSACleanup();
        return 1;
    }

    SOCKET sockServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockServer == INVALID_SOCKET)
    {
        cout << "socket create failed with code: "<< WSAGetLastError() << endl;
        WSACleanup();
        return 1;
    }

    sockaddr_in addInfo;
    addInfo.sin_family = AF_INET;
    addInfo.sin_port = htons(12345);
    addInfo.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    int nBindRet = bind(sockServer, reinterpret_cast<sockaddr*>(&addInfo), sizeof(addInfo));
    if (SOCKET_ERROR == nBindRet)
    {
        cout << "bind failed with code: " << WSAGetLastError() << endl;
        closesocket(sockServer);
        WSACleanup();
        return 1;
    }

    int nListenRet = listen(sockServer, SOMAXCONN);
    if (SOCKET_ERROR == nBindRet)
    {
        cout << "bind failed with code: " << WSAGetLastError() << endl;
        closesocket(sockServer);
        WSACleanup();
        return 1;
    }

    fd_set allSockets;
    FD_ZERO(&allSockets);
    FD_SET(sockServer, &allSockets);
    struct timeval tv = { 3,0 };

    while (1)
    {
        fd_set tmpAllSockets = allSockets;
        int nSelectRet = select(0, &tmpAllSockets, NULL, NULL, &tv);
        if(nSelectRet == 0) continue;        //超时
        else if (nSelectRet == -1)            //出错
        {
            cout << "select failed with code: " << WSAGetLastError() << endl;
            break;
        }
        else if (nSelectRet > 0)
        {
            for (int i = 0; i < tmpAllSockets.fd_count; i++)
            {
                SOCKET socketID = tmpAllSockets.fd_array[i];

                if (socketID == sockServer)
                {
                    SOCKET socketClient = accept(socketID, NULL, NULL);
                    if (socketClient == INVALID_SOCKET)
                        continue;

                    FD_SET(socketClient, &allSockets);
                }
                else
                {
                    char buf[1024] = { 0 };
                    int nRecvRet = recv(socketID, buf, 1024, 0);
                    if (nRecvRet == 0)        //客户端断开连接
                    {
                        FD_CLR(socketID, &allSockets);
                        closesocket(socketID);
                        continue;
                    }
                    else if (nRecvRet > 0)
                    {
                        cout << socketID << " : " << buf << endl;
                        send(socketID, "我收到了你发送的数据！", sizeof("我收到了你发送的数据！"), 0);
                    }
                    else if (nRecvRet == SOCKET_ERROR)
                    {
                        int nError = WSAGetLastError();
                        if (nError == 10054)
                        {
                            FD_CLR(socketID, &allSockets);
                            closesocket(socketID);
                            continue;
                        }
                        else
                            cout << "recv error." << endl;
                    }
                }
            }
        }
    }

    for (int i = 0; i < allSockets.fd_count; i++)
    {
        closesocket(allSockets.fd_array[i]);
    }
    FD_ZERO(&allSockets);
    WSACleanup();
    return 0;
}

总结

select模型有以下优点：

• select允许同时监视多个套接字的读写状态，使得在单个线程中可以处理多个套接字的I/O操作，提高了系统的效率。
• select模型使用简单，适合初学者设计简单的网络通信。

select模型有以下缺点：

• select()函数本身会造成阻塞。
• 由于需要遍历整个被监视的套接字集合，在大规模并发场景下，select模型性能低下。
• 受限于FD_SET集合有大小限制，后续的拓展性差，无法适用于高并发场景。
• 无法处理大量数据，如果有大量数据需要处理，会导致阻塞其他套接字的读写。