深入理解 Linux 进程间通信（IPC）机制|dc的house

在操作系统中，进程是程序执行的基本单位。每个进程都有自己独立的地址空间，相互隔离，因此进程间的通信（Inter-Process Communication，IPC）是一个复杂而重要的问题。Linux 提供了多种 IPC 机制，帮助进程之间进行数据交换和同步。本文将详细介绍这些 IPC 机制，并通过图表和代码示例帮助你更好地理解。

1. 进程间通信（IPC）简介

进程间通信是指两个或多个进程之间进行数据交换和同步的机制。由于每个进程都有自己独立的地址空间，进程间的通信需要通过操作系统提供的机制来实现。

1.1 为什么需要 IPC？

任务分解：将复杂的任务分解为多个进程，每个进程负责一部分工作。
资源共享：多个进程需要共享某些资源（如内存、文件等）。
数据交换：进程之间需要传递数据（如客户端和服务器之间的通信）。

2. Linux 中的 IPC 机制

Linux 提供了多种 IPC 机制，主要包括以下几类：

IPC 机制	特点	适用场景
管道（Pipe）	单向通信，只能在父子或兄弟进程间使用	简单的进程间通信
FIFO（命名管道）	双向通信，可以在不相关的进程间使用	不相关进程间的通信
信号（Signal）	用于通知进程某个事件的发生	进程间的事件通知
消息队列	消息的链表，支持格式化的数据传输	复杂的进程间通信
信号量	用于进程间的同步，控制对共享资源的访问	进程同步和资源共享
共享内存	多个进程共享同一块内存区域，速度最快	高性能的进程间通信
套接字（Socket）	基于网络的 IPC，支持不同主机间的进程通信	网络通信

3. 管道（Pipe）

管道是 UNIX 系统上最古老的 IPC 机制，用于在具有亲缘关系的进程间进行通信。

3.1 特点

单向通信：数据只能单向流动。
亲缘关系：只能在父子或兄弟进程间使用。
匿名管道：没有名字，只能通过文件描述符访问。

3.2 代码示例

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd[2];
    pid_t pid;
    char buf[128];

    // 创建管道
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // 子进程：读取数据
        close(fd[1]);  // 关闭写端
        read(fd[0], buf, sizeof(buf));
        printf("子进程收到: %s\n", buf);
        close(fd[0]);
    } else {
        // 父进程：写入数据
        close(fd[0]);  // 关闭读端
        const char *msg = "Hello from parent!";
        write(fd[1], msg, strlen(msg) + 1);
        close(fd[1]);
    }

    return 0;
}

输出：

子进程收到: Hello from parent!

4. FIFO（命名管道）

FIFO 是一种特殊的管道，可以在不相关的进程间进行通信。

4.1 特点

双向通信：支持双向数据传输。
命名管道：通过文件系统中的路径名访问。

4.2 代码示例

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>

int main() {
    const char *fifo_path = "/tmp/my_fifo";
    mkfifo(fifo_path, 0666);  // 创建 FIFO

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // 子进程：读取数据
        int fd = open(fifo_path, O_RDONLY);
        char buf[128];
        read(fd, buf, sizeof(buf));
        printf("子进程收到: %s\n", buf);
        close(fd);
    } else {
        // 父进程：写入数据
        int fd = open(fifo_path, O_WRONLY);
        const char *msg = "Hello from parent!";
        write(fd, msg, strlen(msg) + 1);
        close(fd);
    }

    unlink(fifo_path);  // 删除 FIFO
    return 0;
}

输出：

子进程收到: Hello from parent!

5. 信号（Signal）

信号用于通知进程某个事件的发生，常用于进程间的事件通知。

5.1 特点

异步通信：信号是异步的，进程无法预测信号的到达时间。
简单通信：只能传递简单的信号值，不能传递复杂数据。

5.2 代码示例

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void sig_handler(int signo) {
    printf("收到信号: %d\n", signo);
}

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

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // 子进程：发送信号
        sleep(1);
        kill(getppid(), SIGUSR1);
    } else {
        // 父进程：等待信号
        printf("父进程等待信号...\n");
        pause();
    }

    return 0;
}

输出：

父进程等待信号...
收到信号: 10

6. 消息队列

消息队列是消息的链表，支持格式化的数据传输。

6.1 特点

格式化数据：可以传递结构化的数据。
异步通信：发送和接收消息的进程不需要同时运行。

6.2 代码示例

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

struct msg_buffer {
    long msg_type;
    char msg_text[128];
};

int main() {
    key_t key = ftok("msg_queue", 65);
    int msgid = msgget(key, 0666 | IPC_CREAT);

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        // 子进程：发送消息
        struct msg_buffer msg;
        msg.msg_type = 1;
        strcpy(msg.msg_text, "Hello from child!");
        msgsnd(msgid, &msg, sizeof(msg), 0);
    } else {
        // 父进程：接收消息
        struct msg_buffer msg;
        msgrcv(msgid, &msg, sizeof(msg), 1, 0);
        printf("父进程收到: %s\n", msg.msg_text);
        msgctl(msgid, IPC_RMID, NULL);  // 删除消息队列
    }

    return 0;
}