linux socket怎么实现多个客户端连接服务器端

在Linux网络编程中，服务器端要同时服务多个客户端，本质上要解决两个问题：一是监听套接字如何持续接收新连接，二是已建立连接的套接字如何同时进行读写。若服务器在某个客户端的阻塞式读写上停留过久，其他客户端就无法及时得到响应。因此，常见实现要么为每个连接创建独立执行流，要么使用IO多路复用机制，在一个执行流中监听多个描述符上的事件。

从接口层面看，服务端通常先通过socket()创建套接字，再用bind()绑定地址和端口，然后调用listen()进入监听状态。当客户端发起连接时，内核会将连接放入队列，服务器再通过accept()取出连接并得到一个新的文件描述符。后续所有并发方案，都是围绕如何妥善处理这个新描述符展开的。

服务端监听套接字的初始化逻辑

无论选择多进程、多线程，还是选择select或epoll，服务端初始化流程基本一致。监听套接字只负责接收连接请求，它本身并不承担业务数据的收发工作。真正与客户端通信的是accept()返回的已连接套接字。理解这一点，是写出正确并发服务器的第一步。

在初始化时，通常会设置SO_REUSEADDR选项，以便服务器程序退出后能够快速重新绑定同一端口。地址字段使用INADDR_ANY表示监听本机所有可用网卡，端口字段需要使用htons()转换为网络字节序。listen()的第二个参数表示内核为该监听套接字维护的连接队列长度，它会影响突发连接场景下的表现。

下面的示例展示了最基础的服务端初始化流程。为了保持示例独立可编译，后续几个方案也会包含相同的初始化函数。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_PORT 8888
#define BACKLOG 128

static int init_server_socket(void)
{
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return -1;
    }

    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

int main(void)
{
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return EXIT_FAILURE;
    }

    printf("server listen on %dn", SERVER_PORT);
    close(server_fd);
    return EXIT_SUCCESS;
}

这个程序只完成了监听套接字的创建，并没有进入真正的并发处理阶段。接下来的重点，是如何在accept()得到客户端描述符之后，让服务器具备同时处理多个客户端的能力。

多进程与多线程：为每个连接分配独立执行流

最直观的并发方式是每接入一个客户端，就创建一个新的执行单元。多进程方案使用fork()复制当前进程，父子进程共享监听套接字的文件描述符表，但各自拥有独立的地址空间。父进程继续调用accept()，子进程负责与客户端通信。为了避免子进程退出后变成僵尸进程，通常还需要捕获SIGCHLD信号，并在信号处理函数中调用waitpid()回收资源。

多线程方案的结构与多进程类似，但使用pthread_create()创建线程。线程共享进程的地址空间，因此创建和切换成本通常低于进程，资源占用也更少。不过，共享内存同时意味着必须关注全局变量、连接表、日志缓冲等数据的线程安全问题。若线程处理完连接后不再需要主线程等待，可以调用pthread_detach()让其退出时自动释放资源。

下面分别给出多进程和多线程的完整示例。两个示例都实现了简单的回显服务：服务器收到客户端数据后，将相同内容发送回去。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>

#define SERVER_PORT 8888
#define BACKLOG 128

static void sigchld_handler(int signo)
{
    (void)signo;
    while (waitpid(-1, NULL, WNOHANG) > 0) {
        /* 只回收已经退出的子进程，避免僵尸进程 */
    }
}

static int init_server_socket(void)
{
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return -1;
    }

    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

int main(void)
{
    signal(SIGCHLD, sigchld_handler);

    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return EXIT_FAILURE;
    }

    struct sockaddr_in client_addr;
    socklen_t client_len;
    char client_ip[INET_ADDRSTRLEN];

    while (1) {
        client_len = sizeof(client_addr);
        int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
        if (client_fd < 0) {
            perror("accept");
            continue;
        }

        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
        printf("new client: %s:%d, fd=%dn",
               client_ip, ntohs(client_addr.sin_port), client_fd);

        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
            close(client_fd);
            continue;
        }

        if (pid == 0) {
            /* 子进程负责当前客户端的数据读写 */
            close(server_fd);

            char buf[1024];
            while (1) {
                ssize_t n = recv(client_fd, buf, sizeof(buf) - 1, 0);
                if (n <= 0) {
                    if (n < 0) {
                        perror("recv");
                    } else {
                        printf("client fd=%d disconnectedn", client_fd);
                    }
                    break;
                }

                buf[n] = '';
                printf("recv from fd=%d: %sn", client_fd, buf);
                send(client_fd, buf, n, 0);
            }

            close(client_fd);
            _exit(EXIT_SUCCESS);
        }

        /* 父进程只保留监听职责，关闭已连接套接字 */
        close(client_fd);
    }

    close(server_fd);
    return EXIT_SUCCESS;
}

多进程方案的优点是隔离性好，一个子进程崩溃通常不会直接拖垮整个服务器。缺点是进程开销较大，连接数上升后，内存和上下文切换成本会明显增加。因此，它更适合连接数量可控、对稳定性要求较高的场景。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>

#define SERVER_PORT 8888
#define BACKLOG 128

struct client_arg {
    int client_fd;
    struct sockaddr_in client_addr;
};

static int init_server_socket(void)
{
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return -1;
    }

    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

static void *client_thread(void *arg)
{
    struct client_arg *carg = (struct client_arg *)arg;
    int client_fd = carg->client_fd;
    struct sockaddr_in client_addr = carg->client_addr;
    char client_ip[INET_ADDRSTRLEN];

    inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));

    /* 分离线程，退出后由系统自动回收资源 */
    pthread_detach(pthread_self());
    free(carg);

    char buf[1024];
    while (1) {
        ssize_t n = recv(client_fd, buf, sizeof(buf) - 1, 0);
        if (n <= 0) {
            if (n < 0) {
                perror("recv");
            } else {
                printf("client %s:%d disconnectedn",
                       client_ip, ntohs(client_addr.sin_port));
            }
            break;
        }

        buf[n] = '';
        printf("recv from %s:%d: %sn",
               client_ip, ntohs(client_addr.sin_port), buf);
        send(client_fd, buf, n, 0);
    }

    close(client_fd);
    return NULL;
}

int main(void)
{
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return EXIT_FAILURE;
    }

    struct sockaddr_in client_addr;
    socklen_t client_len;
    char client_ip[INET_ADDRSTRLEN];

    while (1) {
        client_len = sizeof(client_addr);
        int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
        if (client_fd < 0) {
            perror("accept");
            continue;
        }

        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
        printf("new client: %s:%d, fd=%dn",
               client_ip, ntohs(client_addr.sin_port), client_fd);

        struct client_arg *carg = (struct client_arg *)malloc(sizeof(struct client_arg));
        if (carg == NULL) {
            perror("malloc");
            close(client_fd);
            continue;
        }

        carg->client_fd = client_fd;
        carg->client_addr = client_addr;

        pthread_t tid;
        if (pthread_create(&tid, NULL, client_thread, carg) != 0) {
            perror("pthread_create");
            free(carg);
            close(client_fd);
            continue;
        }
    }

    close(server_fd);
    return EXIT_SUCCESS;
}

多线程方案适合中等规模连接。它比多进程轻量，但每个线程仍然有独立的栈空间和调度成本。当客户端数量达到数千甚至更高时，为每个连接创建一个线程的模型会遇到瓶颈，这时更适合使用IO多路复用。

select多路复用：用单个线程监视多个描述符

如果不想为每个连接都创建进程或线程，可以让一个主线程同时监视多个文件描述符。select就是较早出现的IO多路复用机制。它将需要监视的描述符放入fd_set集合，然后调用select()阻塞等待。只要集合中任意描述符变为可读、可写或出现异常，函数就会返回，程序再遍历集合判断具体是哪一个描述符就绪。

在TCP服务器中，通常把监听套接字和所有已连接客户端套接字都加入读事件集合。若监听套接字就绪，说明有新的客户端连接，需要调用accept()并把新描述符加入集合；若某个客户端描述符就绪，则调用recv()读取数据。若读取返回零或错误，则关闭该描述符，并从集合中移除。

下面的示例使用一个数组保存当前所有客户端描述符，并在每轮循环中重新构建fd_set。这种写法便于理解，也符合select的典型使用方式。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_PORT 8888
#define BACKLOG 128

static int init_server_socket(void)
{
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return -1;
    }

    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

int main(void)
{
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return EXIT_FAILURE;
    }

    if (server_fd >= FD_SETSIZE) {
        fprintf(stderr, "server fd is too largen");
        close(server_fd);
        return EXIT_FAILURE;
    }

    int client_fds[FD_SETSIZE];
    for (int i = 0; i < FD_SETSIZE; i++) {
        client_fds[i] = -1;
    }

    while (1) {
        fd_set read_fds;
        FD_ZERO(&read_fds);
        FD_SET(server_fd, &read_fds);
        int max_fd = server_fd;

        for (int i = 0; i < FD_SETSIZE; i++) {
            if (client_fds[i] != -1) {
                FD_SET(client_fds[i], &read_fds);
                if (client_fds[i] > max_fd) {
                    max_fd = client_fds[i];
                }
            }
        }

        int ready = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
        if (ready < 0) {
            perror("select");
            break;
        }

        if (FD_ISSET(server_fd, &read_fds)) {
            struct sockaddr_in client_addr;
            socklen_t client_len = sizeof(client_addr);
            int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
            if (client_fd < 0) {
                perror("accept");
            } else {
                char client_ip[INET_ADDRSTRLEN];
                inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
                printf("new client: %s:%d, fd=%dn",
                       client_ip, ntohs(client_addr.sin_port), client_fd);

                int added = 0;
                for (int i = 0; i < FD_SETSIZE; i++) {
                    if (client_fds[i] == -1) {
                        client_fds[i] = client_fd;
                        added = 1;
                        break;
                    }
                }

                if (!added) {
                    printf("too many clients, reject new connectionn");
                    close(client_fd);
                }
            }
        }

        for (int i = 0; i < FD_SETSIZE; i++) {
            int client_fd = client_fds[i];
            if (client_fd != -1 && FD_ISSET(client_fd, &read_fds)) {
                char buf[1024];
                ssize_t n = recv(client_fd, buf, sizeof(buf) - 1, 0);
                if (n <= 0) {
                    if (n < 0) {
                        perror("recv");
                    } else {
                        printf("client fd=%d disconnectedn", client_fd);
                    }
                    close(client_fd);
                    client_fds[i] = -1;
                } else {
                    buf[n] = '';
                    printf("recv from fd=%d: %sn", client_fd, buf);
                    send(client_fd, buf, n, 0);
                }
            }
        }
    }

    close(server_fd);
    return EXIT_SUCCESS;
}

需要注意的是，select的可用描述符数量受FD_SETSIZE限制，常见默认值为1024。同时，每次调用前都要重新设置描述符集合，返回后也要线性遍历所有描述符。当连接数较多且活跃连接比例较高时，效率会下降。因此，它更适合连接数较少、跨平台需求明显或用于理解IO多路复用原理的场景。

epoll与方案选择：面向高并发的推荐路径

在Linux环境下，如果希望支撑更高并发，通常优先选择epoll。它不再要求程序每次把所有描述符集合整体传入内核，而是通过epoll_ctl()注册感兴趣的描述符和事件。调用epoll_wait()时，内核只返回已经就绪的描述符，避免了对大量未就绪描述符的无效遍历。

从编程模型看，服务器先创建epoll实例，然后把监听套接字加入监视范围。当监听套接字上有连接到达时，调用accept()获取客户端描述符，并继续把它加入epoll。当客户端描述符上有读事件时，再进行数据读取和回写。若客户端断开，则通过EPOLL_CTL_DEL移除该描述符并关闭文件描述符。

下面是一个基于epoll的完整回显服务器示例。为了降低理解成本，示例使用默认的水平触发模式，只要描述符仍处于可读状态，epoll_wait()就会持续通知。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_PORT 8888
#define BACKLOG 128
#define MAX_EVENTS 1024

static int init_server_socket(void)
{
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket");
        return -1;
    }

    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }

    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(SERVER_PORT);

    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }

    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

int main(void)
{
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return EXIT_FAILURE;
    }

    int epoll_fd = epoll_create(128);
    if (epoll_fd < 0) {
        perror("epoll_create");
        close(server_fd);
        return EXIT_FAILURE;
    }

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = server_fd;

    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev) < 0) {
        perror("epoll_ctl add server_fd");
        close(server_fd);
        close(epoll_fd);
        return EXIT_FAILURE;
    }

    struct epoll_event events[MAX_EVENTS];

    while (1) {
        int ready = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (ready < 0) {
            perror("epoll_wait");
            break;
        }

        for (int i = 0; i < ready; i++) {
            int fd = events[i].data.fd;

            if (fd == server_fd) {
                struct sockaddr_in client_addr;
                socklen_t client_len = sizeof(client_addr);
                int client_fd = accept(server_fd,
                                       (struct sockaddr *)&client_addr,
                                       &client_len);
                if (client_fd < 0) {
                    perror("accept");
                    continue;
                }

                char client_ip[INET_ADDRSTRLEN];
                inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
                printf("new client: %s:%d, fd=%dn",
                       client_ip, ntohs(client_addr.sin_port), client_fd);

                struct epoll_event client_event;
                client_event.events = EPOLLIN;
                client_event.data.fd = client_fd;

                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &client_event) < 0) {
                    perror("epoll_ctl add client_fd");
                    close(client_fd);
                }
            } else if (events[i].events & (EPOLLIN | EPOLLERR | EPOLLHUP)) {
                char buf[1024];
                ssize_t n = recv(fd, buf, sizeof(buf) - 1, 0);
                if (n <= 0) {
                    if (n < 0) {
                        perror("recv");
                    } else {
                        printf("client fd=%d disconnectedn", fd);
                    }
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, NULL);
                    close(fd);
                } else {
                    buf[n] = '';
                    printf("recv from fd=%d: %sn", fd, buf);
                    send(fd, buf, n, 0);
                }
            }
        }
    }

    close(epoll_fd);
    close(server_fd);
    return EXIT_SUCCESS;
}

与前面的方案相比，epoll更适合连接数多、但同一时刻只有部分连接活跃的典型网络服务。它可以用较少线程承担大量连接，也方便进一步结合非阻塞IO、线程池或事件循环框架。若业务逻辑较轻，单线程epoll即可获得很好的吞吐能力；若业务处理耗时，则可以把就绪事件分发给工作线程，避免阻塞事件循环。

选型时可以参考以下思路：

• 连接数较少、逻辑简单且希望隔离故障时，可以考虑多进程。
• 连接数中等、业务需要共享较多进程内数据时，可以考虑多线程。
• 需要跨平台理解IO多路复用，或连接规模受限时，可以使用select。
• 在Linux上追求高并发、低开销的事件驱动模型时，优先选择epoll。

综合来看，Linux下实现多个客户端连接服务器端并没有唯一答案，关键取决于连接规模、业务复杂度和系统资源约束。多进程模型简单且隔离性好，多线程模型更轻量，select便于理解跨平台IO多路复用，而epoll则是Linux高并发服务端的常用选择。无论采用哪种方案，都应先确保监听套接字初始化正确，再围绕accept()返回的新描述符设计并发策略。

在实际项目中，还建议关注描述符数量上限、错误处理、半关闭状态、粘包拆包以及优雅退出等问题。只有在并发模型与业务协议都设计合理的情况下，服务器才能在高负载下保持稳定响应。

linux_socket多客户端连接服务器端实现select多路复用epoll修改时间：2026-07-10 23:27:55