Linux C++如何进行多进程通信

在Linux环境下，用C++实现多进程通信（IPC），其实可选的方案比想象中要多不少。从最经典的管道，到速度最快的共享内存，再到适用于网络通信的套接字——每种机制都有自己的适用场景和取舍。下面就来逐一梳理，并附上简单的代码示例，方便大家快速上手。

1. 管道（Pipes）：
   匿名管道通常用于父子进程间通信，而命名管道（FIFO）则允许任意两个无亲缘关系的进程交换数据。两者本质都是字节流，用法简单，但不支持随机访问。
2. 信号（Signals）：
   适合传递简单的事件通知，比如终止进程、暂停执行或触发自定义处理函数。它轻量但能携带的信息非常有限。
3. 消息队列（Message Queues）：
   进程可以通过消息队列发送和接收结构化的数据块。相比管道，它能更好地处理多条消息的优先级和边界。
4. 共享内存（Shared Memory）：
   多个进程直接读写同一块物理内存，速度在所有IPC机制中是最快的。当然，速度快也意味着你需要搭配信号量或互斥锁来避免竞争。
5. 信号量（Semaphores）：
   这种机制本身不传递数据，而是用来同步对共享资源的访问。常与共享内存搭配使用，保证并发安全。
6. 套接字（Sockets）：
   Unix Domain Sockets专门用于本地进程间通信，而网络套接字则能跨越不同主机。它们的接口统一，开发人员通常比较熟悉。
7. 内存映射文件（Memory-mapped Files）：
   将文件映射到进程的地址空间，多个进程通过映射同一文件实现数据共享。这种方式既保留了文件的持久化特性，又兼具共享内存的高效。

下面是一些简单的示例代码，展示如何在C++中使用这些常见的IPC机制：

匿名管道

#include 
#include 
#include 
#include 

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[10];

    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) { // 父进程
        close(pipefd[0]); // 关闭不需要的读端
        write(pipefd[1], "Hello from parent!", 20);
        close(pipefd[1]); // 关闭写端
        wait(NULL); // 等待子进程结束
    } else { // 子进程
        close(pipefd[1]); // 关闭不需要的写端
        read(pipefd[0], buffer, sizeof(buffer));
        std::cout << "Child received: " << buffer << std::endl;
        close(pipefd[0]); // 关闭读端
    }

    return 0;
}

命名管道（FIFO）

#include 
#include 
#include 
#include 

int main() {
    const char* fifo = "/tmp/myfifo";
    mkfifo(fifo, 0666);

    int fd = open(fifo, O_RDWR);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    const char* message = "Hello from FIFO!";
    write(fd, message, strlen(message) + 1);

    char buffer[10];
    read(fd, buffer, sizeof(buffer));
    std::cout << "Received: " << buffer << std::endl;

    close(fd);
    unlink(fifo); // 删除FIFO
    return 0;
}

共享内存

#include 
#include 
#include 
#include 

int main() {
    key_t key = ftok("shmfile", 65);
    int shmid = shmget(key, 1024, 0666|IPC_CREAT);

    char *str = (char*) shmat(shmid, (void*)0, 0);
    strcpy(str, "Hello from shared memory!");
    std::cout << "Shared memory: " << str << std::endl;

    shmdt(str);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

信号量

#include 
#include 
#include 

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main() {
    key_t key = ftok("semfile", 65);
    int semid = semget(key, 1, 0666|IPC_CREAT);

    union semun arg;
    arg.val = 1; // 初始化信号量为1
    semctl(semid, 0, SETVAL, arg);

    // 使用semop进行P操作（等待）
    struct sembuf sb = {0, -1, SEM_UNDO};
    semop(semid, &sb, 1);
    std::cout << "Semaphore P operation completed." << std::endl;

    // 使用semop进行V操作（释放）
    sb.sem_op = 1;
    semop(semid, &sb, 1);

    semctl(semid, 0, IPC_RMID);
    return 0;
}

在使用这些IPC机制时，有几个地方需要特别留意。比如，同步问题首当其冲——无论是共享内存还是管道，不加锁或信号量的话，竞态条件随时可能冒出来。另外，错误处理和资源清理也不能马虎，尤其要注意关闭文件描述符、释放共享内存段、删除命名管道和信号量等。把这些基本功做到位，程序才能跑得又稳又快。