Winsock中accept()函数工作原理及多连接优雅处理方法咨询

你当前的代码只调用了一次accept，且用单个变量存储连接套接字，自然会被新连接覆盖。要优雅处理多连接，下面是几种从易到难的常用方案：

1. 多线程方案（入门首选） #

每次accept成功拿到新连接套接字后，启动独立线程处理该套接字的读写、通信逻辑，主线程继续循环调用accept等待新连接。

优点：逻辑简单，容易理解实现，适合学习阶段；
缺点：连接数过多时线程开销大，小场景下完全够用。

示例代码：

#include <thread>
#include <vector>
#include <mutex>
#include <algorithm>

// 存储已连接套接字，用互斥锁保证线程安全
std::vector<SOCKET> connectedSockets;
std::mutex socketsMutex;

// 单个连接的处理逻辑
void handleClient(SOCKET clientSocket) {
    char recvBuf[1024];
    int result;

    // 循环接收客户端数据
    do {
        result = recv(clientSocket, recvBuf, sizeof(recvBuf), 0);
        if (result > 0) {
            PRINT("Received %d bytes", result);
            // 示例：回发接收到的数据
            send(clientSocket, recvBuf, result, 0);
        } else if (result == 0) {
            PRINT("Client disconnected");
        } else {
            PRINT("recv failed: %d", WSAGetLastError());
        }
    } while (result > 0);

    // 关闭套接字并从列表中移除
    closesocket(clientSocket);
    std::lock_guard<std::mutex> lock(socketsMutex);
    auto it = std::find(connectedSockets.begin(), connectedSockets.end(), clientSocket);
    if (it != connectedSockets.end()) {
        connectedSockets.erase(it);
    }
}

// 主线程监听逻辑
void startListening() {
    // ... 省略socket创建、bind、listen的前置代码 ...

    PRINT("Listening...");
    while (true) {
        SOCKET newClient = accept(ListenSocket, nullptr, nullptr);
        if (newClient == INVALID_SOCKET) {
            PRINT("accept failed: %d", WSAGetLastError());
            closesocket(ListenSocket);
            return;
        }

        PRINT("New client connected");
        // 加锁存入套接字列表
        std::lock_guard<std::mutex> lock(socketsMutex);
        connectedSockets.push_back(newClient);
        // 启动线程处理该连接，detach让线程后台运行
        std::thread(handleClient, newClient).detach();
    }
}

2. select多路复用模型（同步IO进阶） #

用select函数同时监听监听套接字和所有已连接套接字的事件，主线程在一个循环里即可同时处理新连接和已连接套接字的读写，无需多线程。

优点：单线程处理多连接，线程开销小，适合中小并发场景；
缺点：套接字数量有默认上限（FD_SETSIZE=64，可修改但仍有局限）。

示例代码：

#include <vector>

void startListening() {
    // ... 省略socket创建、bind、listen的前置代码 ...

    PRINT("Listening...");
    std::vector<SOCKET> connectedSockets;
    fd_set readFds;
    int maxSocket;

    while (true) {
        // 每次循环重新初始化fd_set（select会修改集合内容）
        FD_ZERO(&readFds);
        FD_SET(ListenSocket, &readFds);
        maxSocket = ListenSocket;

        // 将所有已连接套接字加入监听集合
        for (SOCKET sock : connectedSockets) {
            FD_SET(sock, &readFds);
            if (sock > maxSocket) maxSocket = sock;
        }

        // 无限等待事件触发
        int result = select(maxSocket + 1, &readFds, nullptr, nullptr, nullptr);
        if (result == SOCKET_ERROR) {
            PRINT("select failed: %d", WSAGetLastError());
            closesocket(ListenSocket);
            return;
        }

        // 处理新连接
        if (FD_ISSET(ListenSocket, &readFds)) {
            SOCKET newClient = accept(ListenSocket, nullptr, nullptr);
            if (newClient == INVALID_SOCKET) {
                PRINT("accept failed: %d", WSAGetLastError());
                continue;
            }
            PRINT("New client connected");
            connectedSockets.push_back(newClient);
        }

        // 处理已连接套接字的读写事件
        for (auto it = connectedSockets.begin(); it != connectedSockets.end(); ) {
            SOCKET sock = *it;
            if (FD_ISSET(sock, &readFds)) {
                char recvBuf[1024];
                int recvResult = recv(sock, recvBuf, sizeof(recvBuf), 0);
                if (recvResult > 0) {
                    PRINT("Received %d bytes", recvResult);
                    send(sock, recvBuf, recvResult, 0); // 回发数据
                    ++it;
                } else {
                    // 客户端断开或出错，清理套接字
                    PRINT("Client disconnected or recv failed");
                    closesocket(sock);
                    it = connectedSockets.erase(it);
                }
            } else {
                ++it;
            }
        }
    }
}

3. IOCP（完成端口）模型（高并发首选） #

这是Windows下性能最优的异步IO模型，专为高并发场景设计，由操作系统内核管理IO事件，效率远高于多线程和select。但实现复杂度较高，建议有一定基础后再深入学习。

核心思路：创建完成端口，将监听套接字和已连接套接字关联到端口，工作线程处理IO完成事件，操作系统会自动将事件分发给空闲的工作线程。

你最初设想的用数组存储套接字是可行的，但必须配合上述多路复用或多线程机制，否则单线程仅循环accept的话，既无法处理已连接套接字的读写，还会因未及时存入数组导致新连接覆盖旧连接的问题。

内容的提问来源于stack exchange，提问作者Schrottiy