Linux下多进程Socket通信示例代码

下面我将提供一个完整的Linux多进程Socket通信示例，包含服务器端和客户端代码。这个示例展示了如何使用fork()创建多个子进程来处理客户端连接，这是经典的”多进程服务器”模型。

一、服务器端代码 (server.c)

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

#define PORT 8080
#define MAX_CLIENTS 10
#define BUFFER_SIZE 1024

void handle_client(int client_socket) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_received;

    printf("Client connected\n");

    while (1) {
        // 接收客户端数据
        bytes_received = recv(client_socket, buffer, BUFFER_SIZE - 1, 0);
        if (bytes_received <= 0) {
            if (bytes_received == 0) {
                printf("Client disconnected\n");
            } else {
                perror("recv failed");
            }
            break;
        }

        buffer[bytes_received] = '\0';
        printf("Received from client: %s\n", buffer);

        // 发送响应
        const char *response = "Message received by server\n";
        send(client_socket, response, strlen(response), 0);
    }

    close(client_socket);
}

int main() {
    int server_socket, client_socket;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    pid_t pid;

    // 创建socket
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 设置地址重用
    int opt = 1;
    if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
        perror("setsockopt failed");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    // 配置服务器地址
    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(PORT);

    // 绑定socket
    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind failed");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    // 监听连接
    if (listen(server_socket, MAX_CLIENTS) == -1) {
        perror("listen failed");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d...\n", PORT);

    // 信号处理，忽略SIGCHLD以避免僵尸进程
    signal(SIGCHLD, SIG_IGN);

    while (1) {
        // 接受客户端连接
        client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_len);
        if (client_socket == -1) {
            if (errno == EINTR) {
                continue; // 被信号中断，继续循环
            }
            perror("accept failed");
            continue;
        }

        // 打印客户端信息
        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, INET_ADDRSTRLEN);
        printf("Accepted connection from %s:%d\n", client_ip, ntohs(client_addr.sin_port));

        // 创建子进程处理客户端
        pid = fork();
        if (pid == -1) {
            perror("fork failed");
            close(client_socket);
            continue;
        }

        if (pid == 0) { // 子进程
            close(server_socket); // 子进程不需要监听socket
            handle_client(client_socket);
            exit(0); // 子进程处理完客户端后退出
        } else { // 父进程
            close(client_socket); // 父进程不需要这个客户端socket
        }
    }

    close(server_socket);
    return 0;
}

二、客户端代码 (client.c)

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

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};
    const char *message = "Hello from client";

    // 创建socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket creation error");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // 将IP地址从字符串转换为二进制形式
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        perror("Invalid address/ Address not supported");
        return -1;
    }

    // 连接服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("Connection Failed");
        return -1;
    }

    printf("Connected to server\n");

    // 发送消息
    send(sock, message, strlen(message), 0);
    printf("Message sent to server\n");

    // 接收响应
    ssize_t bytes_received = recv(sock, buffer, BUFFER_SIZE - 1, 0);
    if (bytes_received > 0) {
        buffer[bytes_received] = '\0';
        printf("Server response: %s\n", buffer);
    } else {
        perror("recv failed");
    }

    close(sock);
    return 0;
}

三、编译和运行

1. 编译服务器端和客户端代码：

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

2. 在一个终端运行服务器：

./server

3. 在另一个终端运行客户端（可以打开多个终端运行多个客户端）：

./client

四、代码说明

1. 服务器端：

• 使用socket()创建TCP socket
• 使用bind()绑定到指定端口
• 使用listen()开始监听连接
• 使用accept()接受客户端连接
• 使用fork()为每个客户端创建子进程
• 子进程调用handle_client()处理客户端通信
• 父进程继续监听新连接

1. 客户端：

• 创建socket并连接到服务器
• 发送消息到服务器
• 接收服务器的响应

1. 多进程处理：

• 每个客户端连接都会创建一个新的子进程
• 子进程处理完客户端后退出
• 父进程忽略SIGCHLD信号以避免僵尸进程

1. 错误处理：

• 对每个系统调用进行错误检查
• 处理被信号中断的情况（EINTR）

五、扩展和改进

1. 进程池：可以使用进程池而不是为每个连接创建新进程，减少fork的开销
2. 信号处理：可以更精细地处理SIGCHLD信号来回收子进程
3. 日志记录：添加日志记录功能
4. 超时处理：为socket操作添加超时机制
5. 多线程版本：可以使用pthread创建多线程服务器

这个示例展示了Linux下多进程Socket通信的基本模式，适合学习和理解进程间通信和网络编程的基本概念。