linux pipe 互斥

Linux中的管道（pipe）是一种进程间通信（IPC）机制，它允许一个进程的输出成为另一个进程的输入。管道本质上是半双工的，数据只能单向流动，而且通常用于具有亲缘关系的进程之间，即由同一个父进程创建的子进程之间。

基础概念

无名管道：最简单的管道形式，存在于内存中，没有名字，只能在具有亲缘关系的进程之间使用。
有名管道（FIFO）：与无名管道类似，但具有文件系统中的路径名，因此可以被任何进程使用，即使它们没有亲缘关系。

互斥问题

在使用管道时，可能会遇到互斥问题，即多个进程尝试同时读写管道时可能会导致数据混乱或丢失。这是因为管道的数据缓冲区是有限的，而且管道本身并不提供内置的同步机制。

解决互斥问题的方法

文件锁：可以使用文件锁（如fcntl系统调用）来同步对管道的访问。
信号量：使用信号量来控制对管道的访问，确保一次只有一个进程可以读写管道。
消息队列：使用消息队列代替管道，因为消息队列提供了更强的同步机制。
线程同步原语：如果是多线程而不是多进程的情况，可以使用互斥锁（mutex）、条件变量等线程同步原语。

示例代码：使用文件锁解决管道互斥问题

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

int main() {
    int pipefd[2];
    pid_t cpid;
    char buf;

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

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

    if (cpid == 0) {    // 子进程
        close(pipefd[1]);  // 关闭写端

        struct flock fl;
        fl.l_type = F_WRLCK;
        fl.l_whence = SEEK_SET;
        fl.l_start = 0;
        fl.l_len = 0;

        if (fcntl(pipefd[0], F_SETLKW, &fl) == -1) {
            perror("fcntl");
            exit(EXIT_FAILURE);
        }

        read(pipefd[0], &buf, 1);
        printf("Child read %c\n", buf);

        fl.l_type = F_UNLCK;
        if (fcntl(pipefd[0], F_SETLK, &fl) == -1) {
            perror("fcntl");
            exit(EXIT_FAILURE);
        }

        close(pipefd[0]);
    } else {            // 父进程
        close(pipefd[0]);  // 关闭读端

        struct flock fl;
        fl.l_type = F_WRLCK;
        fl.l_whence = SEEK_SET;
        fl.l_start = 0;
        fl.l_len = 0;

        if (fcntl(pipefd[1], F_SETLKW, &fl) == -1) {
            perror("fcntl");
            exit(EXIT_FAILURE);
        }

        write(pipefd[1], "a", 1);
        printf("Parent wrote 'a'\n");

        fl.l_type = F_UNLCK;
        if (fcntl(pipefd[1], F_SETLK, &fl) == -1) {
            perror("fcntl");
            exit(EXIT_FAILURE);
        }

        close(pipefd[1]);
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

在这个示例中，我们使用了文件锁来确保在任何时候只有一个进程可以访问管道。父进程和子进程都会尝试获取写锁，这样就可以避免同时写入导致的数据混乱。