linux socket怎么实现使用线程独立收发消息

在linux网络编程场景中，socket通信的收发操作如果放在同一个执行流中，很容易出现接收消息时阻塞发送、或者发送消息时阻塞接收的问题，使用线程将收发逻辑分离是解决这个问题的高效方案，两个线程可以独立运行，互不干扰。

实现核心思路

整个实现流程可以分为几个核心步骤：首先完成socket的创建、绑定、监听（服务端）或者连接（客户端）的基础流程，获取到可用的通信socket描述符之后，创建两个线程，一个线程专门负责接收消息，另一个线程专门负责发送消息，两个线程共享这个socket描述符，同时需要注意线程间的资源同步，避免重复关闭socket等问题。

服务端实现示例

服务端需要先创建监听socket，接受客户端连接后，针对每个客户端的通信socket创建收发线程，下面是完整的服务端代码：

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

#define PORT 8080
#define BUFFER_SIZE 1024

// 接收线程函数，参数为通信socket描述符
void* receive_thread(void* arg) {
    int client_sock = *(int*)arg;
    char buffer[BUFFER_SIZE];
    int read_len;
    while (1) {
        memset(buffer, 0, sizeof(buffer));
        read_len = read(client_sock, buffer, BUFFER_SIZE - 1);
        if (read_len <= 0) {
            printf("客户端断开连接，接收线程退出n");
            break;
        }
        printf("收到客户端消息：%sn", buffer);
    }
    return NULL;
}

// 发送线程函数，参数为通信socket描述符
void* send_thread(void* arg) {
    int client_sock = *(int*)arg;
    char buffer[BUFFER_SIZE];
    while (1) {
        memset(buffer, 0, sizeof(buffer));
        printf("请输入要发送的消息：");
        fgets(buffer, BUFFER_SIZE, stdin);
        // 去除fgets读取的换行符
        buffer[strcspn(buffer, "n")] = 0;
        if (strlen(buffer) == 0) {
            continue;
        }
        int send_len = write(client_sock, buffer, strlen(buffer));
        if (send_len <= 0) {
            printf("发送失败，发送线程退出n");
            break;
        }
    }
    return NULL;
}

int main() {
    int server_sock, client_sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    pthread_t recv_tid, send_tid;

    // 创建socket
    server_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sock < 0) {
        perror("socket创建失败");
        exit(1);
    }

    // 设置端口复用
    int opt = 1;
    setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 绑定地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);
    if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind失败");
        close(server_sock);
        exit(1);
    }

    // 监听
    if (listen(server_sock, 5) < 0) {
        perror("listen失败");
        close(server_sock);
        exit(1);
    }
    printf("服务端启动，监听端口%dn", PORT);

    // 接受客户端连接
    client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &client_len);
    if (client_sock < 0) {
        perror("accept失败");
        close(server_sock);
        exit(1);
    }
    printf("客户端连接成功n");

    // 创建接收线程和发送线程，传入客户端socket描述符
    pthread_create(&recv_tid, NULL, receive_thread, &client_sock);
    pthread_create(&send_tid, NULL, send_thread, &client_sock);

    // 等待线程结束
    pthread_join(recv_tid, NULL);
    pthread_join(send_tid, NULL);

    // 关闭socket
    close(client_sock);
    close(server_sock);
    return 0;
}

客户端实现示例

客户端的实现逻辑和服务端类似，也是先创建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>
#include <pthread.h>

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 8080
#define BUFFER_SIZE 1024

// 接收线程函数
void* client_receive_thread(void* arg) {
    int sock = *(int*)arg;
    char buffer[BUFFER_SIZE];
    int read_len;
    while (1) {
        memset(buffer, 0, sizeof(buffer));
        read_len = read(sock, buffer, BUFFER_SIZE - 1);
        if (read_len <= 0) {
            printf("服务端断开连接，接收线程退出n");
            break;
        }
        printf("收到服务端消息：%sn", buffer);
    }
    return NULL;
}

// 发送线程函数
void* client_send_thread(void* arg) {
    int sock = *(int*)arg;
    char buffer[BUFFER_SIZE];
    while (1) {
        memset(buffer, 0, sizeof(buffer));
        printf("请输入要发送的消息：");
        fgets(buffer, BUFFER_SIZE, stdin);
        buffer[strcspn(buffer, "n")] = 0;
        if (strlen(buffer) == 0) {
            continue;
        }
        int send_len = write(sock, buffer, strlen(buffer));
        if (send_len <= 0) {
            printf("发送失败，发送线程退出n");
            break;
        }
    }
    return NULL;
}

int main() {
    int sock;
    struct sockaddr_in server_addr;
    pthread_t recv_tid, send_tid;

    // 创建socket
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket创建失败");
        exit(1);
    }

    // 设置服务端地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
        perror("地址转换失败");
        close(sock);
        exit(1);
    }

    // 连接服务端
    if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect失败");
        close(sock);
        exit(1);
    }
    printf("连接服务端成功n");

    // 创建收发线程
    pthread_create(&recv_tid, NULL, client_receive_thread, &sock);
    pthread_create(&send_tid, NULL, client_send_thread, &sock);

    // 等待线程结束
    pthread_join(recv_tid, NULL);
    pthread_join(send_tid, NULL);

    close(sock);
    return 0;
}

实现注意事项

• 线程参数传递时，不要传递局部变量的地址，上面的示例中如果client_sock是main函数的局部变量，需要注意线程启动后该变量的生命周期，避免线程访问已经失效的地址，这里因为线程在main函数结束前就执行完毕，所以是安全的。
• 两个线程共享同一个socket描述符，不要在两个线程中分别调用close关闭socket，否则会导致另一个线程的socket操作失效，最好在其中一个线程退出后，通知另一个线程退出，再由主线程统一关闭socket。
• 如果需要在多线程中同时调用write发送消息，需要注意write操作的原子性，短消息的write通常是原子的，长消息可能需要加锁保证发送完整。
• 接收线程中判断read返回值小于等于0时，说明连接已经断开，此时需要退出线程，同时可以通过设置标志位的方式通知发送线程也退出，避免发送线程继续向已经断开的socket写数据。

编译运行方法

代码使用pthread库，编译时需要加上-lpthread参数，比如编译服务端：

gcc server.c -o server -lpthread
gcc client.c -o client -lpthread

先启动服务端，再启动客户端，就可以在两个终端分别输入消息，实现独立的收发功能，接收线程会实时打印收到的消息，发送线程可以独立输入要发送的内容，两者不会互相阻塞。

linux_socketthreadsend_messagereceive_message修改时间：2026-07-21 04:18:39