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

在linux网络编程中，实现多个客户端同时连接服务器端是常见需求，核心是在不阻塞主流程的前提下，同时监听和处理多个客户端的连接请求与数据交互。下面先介绍基础的服务端socket初始化流程，再逐步讲解不同多客户端连接实现方案。

基础socket服务端初始化流程

无论采用哪种多客户端连接方案，服务端的基础初始化步骤都是一致的，主要包含创建socket、绑定地址端口、监听连接三个核心步骤，代码如下：

#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 10  // 内核维护的半连接和全连接队列长度

int init_server_socket() {
    // 创建TCP socket
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket create failed");
        return -1;
    }

    // 设置端口复用，避免服务端重启时端口被占用
    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt failed");
        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 failed");
        close(server_fd);
        return -1;
    }

    // 开始监听连接
    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen failed");
        close(server_fd);
        return -1;
    }

    printf("server init success, listen on port %dn", SERVER_PORT);
    return server_fd;
}

方案一：多进程处理多客户端连接

多进程方案的核心逻辑是，服务端通过fork()函数创建子进程，每个子进程负责处理一个客户端的连接，父进程继续监听新的连接请求。这种方案实现简单，进程之间相互独立，一个客户端异常不会影响其他客户端。

实现步骤如下：

• 父进程调用accept()阻塞等待客户端连接
• 当有新连接到来时，accept()返回客户端的socket文件描述符
• 父进程调用fork()创建子进程，子进程处理该客户端的读写操作
• 父进程关闭客户端socket描述符，继续回到accept()等待新连接

完整代码示例如下：

#include <sys/wait.h>
#include <signal.h>

// 信号处理函数，回收子进程，避免僵尸进程
void sig_child_handler(int signo) {
    pid_t pid;
    int stat;
    // 循环回收所有已结束的子进程
    while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        printf("child process %d exitn", pid);
    }
}

int main() {
    // 注册SIGCHLD信号处理函数
    signal(SIGCHLD, sig_child_handler);

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

    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    char client_ip[INET_ADDRSTRLEN];

    while (1) {
        // 阻塞等待客户端连接
        int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
        if (client_fd < 0) {
            perror("accept failed");
            continue;
        }

        // 转换客户端地址为字符串格式
        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
        printf("new client connect: %s:%d, fd=%dn", client_ip, ntohs(client_addr.sin_port), client_fd);

        // 创建子进程处理客户端
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork failed");
            close(client_fd);
        } else if (pid == 0) {
            // 子进程逻辑，关闭服务端监听socket
            close(server_fd);
            char recv_buf[1024];
            while (1) {
                memset(recv_buf, 0, sizeof(recv_buf));
                int recv_len = recv(client_fd, recv_buf, sizeof(recv_buf)-1, 0);
                if (recv_len <= 0) {
                    if (recv_len < 0) {
                        perror("recv failed");
                    } else {
                        printf("client fd=%d disconnectn", client_fd);
                    }
                    break;
                }
                printf("recv from client %s:%d, data: %sn", client_ip, ntohs(client_addr.sin_port), recv_buf);
                // 回显数据给客户端
                send(client_fd, recv_buf, recv_len, 0);
            }
            close(client_fd);
            exit(0);
        } else {
            // 父进程逻辑，关闭客户端socket，继续监听
            close(client_fd);
        }
    }

    close(server_fd);
    return 0;
}

该方案的缺点是进程创建和切换开销较大，当客户端数量过多时，会占用大量系统资源，适合客户端数量较少的场景。

方案二：多线程处理多客户端连接

多线程方案与多进程思路类似，区别是创建线程而非进程，线程共享进程的资源，创建和切换开销比进程小，资源占用更少。需要注意线程安全问题和线程资源的回收。

实现时需要为每个客户端连接创建一个工作线程，线程处理完客户端交互后自动退出，主线程可以继续接收新连接。完整代码如下：

#include <pthread.h>

// 线程参数结构体，传递客户端socket和地址信息
typedef struct {
    int client_fd;
    struct sockaddr_in client_addr;
} thread_arg;

// 线程处理函数
void* client_thread_handler(void* arg) {
    thread_arg* t_arg = (thread_arg*)arg;
    int client_fd = t_arg->client_fd;
    struct sockaddr_in client_addr = t_arg->client_addr;
    char client_ip[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));

    // 分离线程，线程退出后自动回收资源，不需要主线程join
    pthread_detach(pthread_self());

    free(arg);  // 释放参数内存

    char recv_buf[1024];
    while (1) {
        memset(recv_buf, 0, sizeof(recv_buf));
        int recv_len = recv(client_fd, recv_buf, sizeof(recv_buf)-1, 0);
        if (recv_len <= 0) {
            if (recv_len < 0) {
                perror("recv failed");
            } else {
                printf("client %s:%d disconnectn", client_ip, ntohs(client_addr.sin_port));
            }
            break;
        }
        printf("recv from client %s:%d, data: %sn", client_ip, ntohs(client_addr.sin_port), recv_buf);
        send(client_fd, recv_buf, recv_len, 0);
    }
    close(client_fd);
    return NULL;
}

int main() {
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return -1;
    }

    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);

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

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

        // 创建线程参数
        thread_arg* t_arg = (thread_arg*)malloc(sizeof(thread_arg));
        t_arg->client_fd = client_fd;
        t_arg->client_addr = client_addr;

        pthread_t tid;
        if (pthread_create(&tid, NULL, client_thread_handler, t_arg) != 0) {
            perror("pthread create failed");
            free(t_arg);
            close(client_fd);
        }
    }

    close(server_fd);
    return 0;
}

多线程方案的线程共享进程内存空间，需要注意全局变量的线程安全，适合中等数量客户端连接的场景，但当客户端数量达到数千级别时，线程切换的开销也会比较明显。

方案三：select多路复用实现多客户端连接

select是linux提供的多路复用IO机制，可以让单个进程同时监听多个文件描述符的读写事件，不需要创建多进程或多线程，资源占用更低。核心是通过select()函数监听一组文件描述符，当有描述符就绪时再进行处理。

实现步骤：

• 创建文件描述符集合，将服务端监听socket加入集合
• 调用select()阻塞监听集合中的描述符
• 当有描述符就绪时，遍历集合判断是新的连接请求还是客户端数据到达
• 处理对应事件，新连接加入监听集合，客户端数据则进行读写操作

完整代码示例如下：

#include <sys/select.h>

#define MAX_CLIENT_NUM 1024  // select最大监听描述符数量，受fd_set限制

int main() {
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return -1;
    }

    // 定义读事件描述符集合
    fd_set read_fds;
    // 记录当前最大的文件描述符
    int max_fd = server_fd;

    // 客户端socket数组，记录所有已连接的客户端
    int client_fds[MAX_CLIENT_NUM];
    for (int i = 0; i < MAX_CLIENT_NUM; i++) {
        client_fds[i] = -1;
    }

    while (1) {
        FD_ZERO(&read_fds);  // 清空集合
        FD_SET(server_fd, &read_fds);  // 将服务端socket加入集合

        // 将已连接的客户端socket加入集合
        for (int i = 0; i < MAX_CLIENT_NUM; i++) {
            if (client_fds[i] != -1) {
                FD_SET(client_fds[i], &read_fds);
                if (client_fds[i] > max_fd) {
                    max_fd = client_fds[i];
                }
            }
        }

        // 阻塞监听读事件，超时时间设为NULL表示永久阻塞
        int ready_num = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
        if (ready_num < 0) {
            perror("select failed");
            break;
        }

        // 判断是否是服务端socket就绪，即有新连接
        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 failed");
                continue;
            }

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

            // 将客户端socket加入数组
            for (int i = 0; i < MAX_CLIENT_NUM; i++) {
                if (client_fds[i] == -1) {
                    client_fds[i] = client_fd;
                    break;
                }
                // 数组已满
                if (i == MAX_CLIENT_NUM - 1) {
                    printf("client array full, reject clientn");
                    close(client_fd);
                }
            }
            ready_num--;
        }

        // 处理客户端数据事件
        if (ready_num > 0) {
            for (int i = 0; i < MAX_CLIENT_NUM && ready_num > 0; i++) {
                if (client_fds[i] != -1 && FD_ISSET(client_fds[i], &read_fds)) {
                    char recv_buf[1024];
                    memset(recv_buf, 0, sizeof(recv_buf));
                    int recv_len = recv(client_fds[i], recv_buf, sizeof(recv_buf)-1, 0);
                    if (recv_len <= 0) {
                        if (recv_len < 0) {
                            perror("recv failed");
                        } else {
                            printf("client fd=%d disconnectn", client_fds[i]);
                        }
                        close(client_fds[i]);
                        client_fds[i] = -1;
                    } else {
                        printf("recv from client fd=%d, data: %sn", client_fds[i], recv_buf);
                        send(client_fds[i], recv_buf, recv_len, 0);
                    }
                    ready_num--;
                }
            }
        }
    }

    close(server_fd);
    return 0;
}

select的缺点是监听的文件描述符数量受fd_set大小限制，默认通常是1024，且每次调用都需要重新设置描述符集合，遍历所有描述符判断就绪状态，当描述符数量很多时效率会下降。

方案四：epoll实现多客户端连接

epoll是linux2.6之后引入的高效多路复用机制，解决了select的诸多缺点，支持监听大量文件描述符，且只会返回就绪的描述符，不需要遍历所有描述符，是高并发场景下的首选方案。

epoll的核心操作有三个：epoll_create创建epoll实例，epoll_ctl添加/修改/删除监听的描述符，epoll_wait等待就绪事件。

完整实现代码如下：

#include <sys/epoll.h>

#define EPOLL_SIZE 1024  // epoll最大事件数量
#define MAX_EVENTS 1024

int main() {
    int server_fd = init_server_socket();
    if (server_fd < 0) {
        return -1;
    }

    // 创建epoll实例
    int epoll_fd = epoll_create(EPOLL_SIZE);
    if (epoll_fd < 0) {
        perror("epoll create failed");
        close(server_fd);
        return -1;
    }

    // 将服务端socket加入epoll监听
    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 failed");
        close(server_fd);
        close(epoll_fd);
        return -1;
    }

    struct epoll_event events[MAX_EVENTS];

    while (1) {
        // 等待就绪事件，超时时间-1表示永久阻塞
        int ready_num = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (ready_num < 0) {
            perror("epoll wait failed");
            break;
        }

        // 处理就绪事件
        for (int i = 0; i < ready_num; i++) {

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