目录

1 ​管道​简介

1.1 分类及原理​

1.2 深入理解命名管道和匿名管道共同点与差异

1.3  重要行为与注意事项

2 C语言实现

2.1 ​​主要的接口​​

2.2 匿名管道示例（进程间）

2.3 命名管道示例（进程间）

2.4 线程间通信示例

3 C++实现

4 面试常见问题

4.1 管道编程与API

4.2 管道核心特性与行为

4.3 管道在嵌入式系统中的应用与设计

4.4 调试与进阶知识

1 ​管道​简介

1.1 分类及原理

​管道是一种​​半双工​​的通信方式，数据只能单向流动。本质是由内核提供的字节流缓冲区，以先进先出（FIFO）的方式在进程间传递数据，通信双方必须同时存在，属于同步、无格式的临时通信机制。管道分为两种：

  • ​​匿名管道​​：用于具有​​亲缘关系​​的进程间（如父子进程、兄弟进程）通信。通过 pipe系统调用创建，返回两个文件描述符，分别用于读和写。其生命周期随进程的结束而结束。

  • ​​命名管道​​：以​​特殊文件​​的形式存在于文件系统中，因此允许​​无亲缘关系​​的进程通过打开该文件进行通信。通过 mkfifo命令或函数创建。

  • ​​一般用于​​：进程间的​​简单、顺序​​的数据流传输，例如将一个命令的输出作为另一个命令的输入（Shell中的 |操作符就是匿名管道），线程之间也可以用管道通信。

匿名管道和命名管道都是 ​​先进先出（FIFO）​​ 的，这是它们的核心特征之一，意味着数据按照写入的顺序依次被读取 。

特性

匿名管道

命名管道 (FIFO)

​​命名与文件系统​​

无名称，不存在于文件系统中

有名称，在文件系统中以特殊文件形式存在（如 /tmp/myfifo）

​​创建方式​​

pipe()系统调用

mkfifo()函数或 mkfifo命令

​​通信范围​​

仅限于具有​​亲缘关系​​的进程（如父子进程）

可用于​​任意进程​​之间（无论是否有亲缘关系）

​​生命周期​​

随创建它的​​进程结束​​而销毁

​​持久存在​​，除非显式删除（unlink），不依赖创建它的进程

​​可见性​​

通过进程​​继承​​文件描述符实现共享，对系统其他进程不可见

通过​​路径名​​访问，只要知道路径且有权限的进程均可访问

1.2 深入理解命名管道和匿名管道共同点与差异

  • ​​共有的管道特性​​

    除了先进先出，匿名管道和命名管道还有一些共同的重要特性 ：

    • ​​单向通信​​：管道默认是单向的。如果需要双向通信，必须建立两个管道。

    • ​​自带同步与互斥​​：当管道为空时，读操作会阻塞直到有数据写入；当管道满时，写操作会阻塞直到有空间读出。这种机制保证了读写进程的协调 。

    • ​​面向字节流​​：管道传输的是无格式的字节流，读写方需自行定义消息边界。

    • ​​内核缓冲区​​：数据暂存于内核缓冲区，而非磁盘，因此通信效率较高 。

  • ​​关键差异解读​​

    • ​​存在形式与访问方式​​：这是最根本的区别。匿名管道没有实体文件，依赖​​文件描述符的继承​​，所以只能用于有亲缘关系的进程 。命名管道则有一个在文件系统里“看得见”的文件名（尽管数据仍在内存中），任何进程都可以通过​​打开这个文件​​来通信，极大地扩展了应用场景 。

    • ​​生命周期​​：匿名管道是临时的，进程结束它就消失了。命名管道则像普通文件一样，会一直存在直到被手动删除，这允许通信进程在不同时间启动 。

1.3  重要行为与注意事项

了解管道在某些边界条件下的行为至关重要：

  1. ​​读写端关闭的影响​​

    • 当管道的​​写端全部关闭​​后，读端在读取完管道内所有数据后，再次 read会返回 0（表示文件结束符 EOF）。

    • 当管道的​​读端全部关闭​​后，写端继续尝试 write会失败，操作系统通常会向写进程发送一个 SIGPIPE信号（默认行为是终止该进程）。

  2. ​​原子性写入​​

    当一次写入管道的数据量​​小于或等于 PIPE_BUF​​（一个系统常量，通常为 4KB）时，Linux 能保证这次写入是​​原子的​​ 。这意味着小于 PIPE_BUF的写入不会与其他进程的写入数据交织在一起。如果写入数据大于 PIPE_BUF，则无法保证原子性。

  3. 多进程通信
    管道（Pipe）是操作系统内核中维护的一段单向字节流缓冲区，常用于父子进程间通信。数据以先进先出（FIFO）方式传输，读一次即消失，不能被多个进程同时读取同一份内容。它更像是一根“内核水管”，一端写入、一端读出，适合一对一或单消费者的数据传递。虽说可以多端写入，但可能存在数据竞争，需要严格设计。

  4. 读写段需规定边界
    在管道通信中，数据是以字节流形式传输的，没有消息边界，操作系统不会自动区分一条条完整的数据包。因此，读端和写端必须事先约定好通信协议——比如每次写入的长度、数据格式、结束标志等。只有这样，读端才能正确地从连续的字节流中解析出一条条有效数据，否则可能出现“数据粘连”或“截断”问题。

  5. 接口标准
    管道最早由 Unix 在 1970 年代早期（Ken Thompson） 引入，作为一种最基础、轻量的 进程间字节流通信机制。最初的“匿名管道（pipe）”只支持有亲缘关系的进程通信（如父子进程），属于 Unix 内核的原生机制，早于任何标准。后来，随着 Unix 的标准化进程，POSIX 标准 将管道接口统一规范化（如 pipe()、pipe2()、popen() 等），并扩展出 命名管道（FIFO） 的接口（mkfifo()），从而支持无亲缘关系进程通信。而 System V 则没有单独定义管道标准，而是提出了更高级的 IPC 机制（消息队列、信号量、共享内存）。因此，管道属于 Unix/POSIX 系列的基础标准，并成为后续 System V IPC 的奠基通信模型。

  6. 管道（pipe）在线程间通信
    线程间可以通过管道发送和接收数据，因为管道是内核维护的缓冲区，读写操作对线程是安全的，但它是字节流、半双工的，并且需要经过系统调用，性能开销较大，因此在同一进程内线程通信中通常不推荐使用，除非为了兼容已有的 IPC 设计。

2 C语言实现

2.1 ​​主要的接口​​

  • int pipe(int fd[2])：创建匿名管道。fd[0]为读端，fd[1]为写端。

  • int mkfifo(const char *pathname, mode_t mode)：创建命名管道文件。

  • read(int fd, void *buf, size_t count)/ write(int fd, const void *buf, size_t count)：对管道进行读写操作。

  • close(int fd[2]) 关闭管道

  • open(FIFO_NAME, O_WRONLY);打开管道

管道通信中，open接口是连接进程与管道（尤其是命名管道）的关键一步。为了让你快速把握其核心要点，下表对比了在不同场景下使用 open的特点：

特性

匿名管道 (Anonymous Pipe)

命名管道 (Named Pipe / FIFO)

​​打开方式​​

由 pipe()系统调用​​自动创建并打开​​，返回 pipefd[0]（读端）和 pipefd[1]（写端）。

需先通过 mkfifo()创建FIFO特殊文件，再使用 open()​​显式打开​​。

​​文件描述符获取​​

通过 pipe()调用的输出参数 pipefd[2]直接获得。

通过 open()调用的返回值获得。

​​打开特性​​

创建后即处于打开状态，无需额外 open操作。

​​打开行为可能引起阻塞​​，取决于打开模式和标志。

​​访问限制​​

通常仅限于具有​​亲缘关系​​的进程（如父子进程）间通信，通过继承文件描述符实现共享。

任何知道FIFO文件路径且有相应权限的​​无关进程​​均可打开并通信。

🔍 关键行为：阻塞与非阻塞模式

命名管道（FIFO）的 open操作有一个非常重要的特性：​​它的默认行为是阻塞的​​。这意味着进程调用 open时可能会被挂起，直到条件满足。具体行为如下表所示：

打开模式 (flags)

没有读端已打开时

没有写端已打开时

说明

O_RDONLY(只读，默认)

​​阻塞​​，直到有进程以 O_WRONLY或 O_RDWR打开该FIFO。

-

确保读端在开始读之前，已经有一个写端准备就绪。

O_WRONLY(只写，默认)

-

​​阻塞​​，直到有进程以 O_RDONLY或 O_RDWR打开该FIFO。

确保写端在开始写之前，已经有一个读端准备就绪，否则写入的数据无人读取。

`O_RDONLY

O_NONBLOCK` (非阻塞只读)

​​立即成功返回​​，即使没有写端。

-

`O_WRONLY

O_NONBLOCK` (非阻塞只写)

-

​​立即返回失败​​ (返回-1，并设置 errno为 ENXIO)，如果没有读端。

O_RDWR(读写)

​​立即成功返回​​。

​​立即成功返回​​。

当前进程同时作为读端和写端，通常用于避免阻塞，但较少用于实际数据交换。

​​重要提示​​：设置 O_NONBLOCK标志不仅影响 open调用本身，也会影响后续的 read和 write操作。例如，在非阻塞模式下读取一个空的FIFO，read会立即返回-1，并将 errno设置为 EAGAIN，而不是阻塞等待。

2.2 匿名管道示例（进程间）

匿名管道适用于有亲缘关系的进程间通信，例如父子进程。其核心步骤是：创建管道、创建子进程、关闭不需要的端口、进行读写操作。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <stdlib.h>

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

    // 1. 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 2. 创建子进程
    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

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

        // 从管道读取数据并打印
        while (read(pipefd[0], &buf, 1) > 0) {
            write(STDOUT_FILENO, &buf, 1);
        }
        write(STDOUT_FILENO, "\n", 1);
        close(pipefd[0]); // 关闭读端
        _exit(EXIT_SUCCESS);

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

        // 向管道写入数据
        const char *message = "Hello from parent process!";
        for (int i = 0; i < strlen(message); i++) {
            write(pipefd[1], &message[i], 1);
        }

        close(pipefd[1]); // 关闭写端会向读端发送EOF
        wait(NULL);      // 等待子进程结束
        exit(EXIT_SUCCESS);
    }
}

2.3 命名管道示例（进程间）

命名管道允许无亲缘关系的进程通信。需要先创建FIFO特殊文件，然后进程像操作普通文件一样打开、读写。

​​写进程 (writer.c)​​

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

#define FIFO_PATH "/tmp/my_fifo"

int main() {
    int fd;
    char buffer[] = "Message from named pipe!";

    // 创建命名管道（如果已存在，mkfifo会失败，但可以忽略）
    mkfifo(FIFO_PATH, 0666);

    printf("等待读进程连接...\n");
    fd = open(FIFO_PATH, O_WRONLY); // 以只写方式打开，会阻塞直到有读进程打开

    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    printf("开始写入数据...\n");
    // 向命名管道写入数据
    if (write(fd, buffer, sizeof(buffer)) == -1) {
        perror("write");
        exit(EXIT_FAILURE);
    }

    close(fd);
    // 通常不在这里删除FIFO，因为读进程可能还需要使用
    // unlink(FIFO_PATH);
    return 0;
}

​​读进程 (reader.c)​​

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

#define FIFO_PATH "/tmp/my_fifo"

int main() {
    int fd;
    char buffer[100];

    printf("等待写进程连接...\n");
    fd = open(FIFO_PATH, O_RDONLY); // 以只读方式打开，会阻塞直到有写进程打开

    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    printf("开始读取数据...\n");
    // 从命名管道读取数据
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
    if (bytes_read == -1) {
        perror("read");
        exit(EXIT_FAILURE);
    }

    printf("接收到的消息: %s\n", buffer);
    close(fd);

    // 通信完成后，可以选择删除FIFO文件
    unlink(FIFO_PATH);
    return 0;
}

2.4 线程间通信示例

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

// 使用两个管道实现双向通信
int pipe_AtoB[2]; // 线程A -> 线程B
int pipe_BtoA[2]; // 线程B -> 线程A

void* threadA_function(void* arg) {
    char buffer[100];
    const char* messageA = "Hello, I'm Thread A!";
    
    // 1. 向线程B发送消息
    write(pipe_AtoB[1], messageA, strlen(messageA) + 1);
    printf("Thread A sent: %s\n", messageA);
    
    // 2. 等待并读取线程B的回复
    read(pipe_BtoA[0], buffer, sizeof(buffer));
    printf("Thread A received: %s\n", buffer);
    
    close(pipe_AtoB[1]);
    close(pipe_BtoA[0]);
    return NULL;
}

void* threadB_function(void* arg) {
    char buffer[100];
    const char* messageB = "Hi Thread A, I'm Thread B!";
    
    // 1. 读取线程A的消息
    read(pipe_AtoB[0], buffer, sizeof(buffer));
    printf("Thread B received: %s\n", buffer);
    
    // 2. 向线程A回复
    write(pipe_BtoA[1], messageB, strlen(messageB) + 1);
    printf("Thread B sent: %s\n", messageB);
    
    close(pipe_AtoB[0]);
    close(pipe_BtoA[1]);
    return NULL;
}

int main() {
    pthread_t threadA, threadB;

    // 创建两个管道
    if (pipe(pipe_AtoB) == -1 || pipe(pipe_BtoA) == -1) {
        perror("pipe creation failed");
        exit(EXIT_FAILURE);
    }

    pthread_create(&threadA, NULL, threadA_function, NULL);
    pthread_create(&threadB, NULL, threadB_function, NULL);

    pthread_join(threadA, NULL);
    pthread_join(threadB, NULL);

    printf("Main thread: Bidirectional communication completed.\n");
    return 0;
}

3 C++实现

与C语言实现基本类似，此外把管道与 std::mutex 和 std::condition_variable 封装在一起，实现线程安全的“内存管道”，类似生产者-消费者模式。

 核心接口设计

template<typename T>
class ThreadPipe {
    std::queue<T> buffer;                  // 内部缓冲区
    std::mutex mtx;                        // 互斥锁
    std::condition_variable cond_not_empty; // 阻塞读等待队列非空
    std::condition_variable cond_not_full;  // 阻塞写等待队列非满
    size_t max_size;                        // 最大容量

public:
    ThreadPipe(size_t max_size_ = 100) : max_size(max_size_) {}

    // 写数据（阻塞）
    void write(const T& item) {
        std::unique_lock<std::mutex> lock(mtx);
        cond_not_full.wait(lock, [this]{ return buffer.size() < max_size; });
        buffer.push(item);
        cond_not_empty.notify_one();
    }

    // 读数据（阻塞）
    T read() {
        std::unique_lock<std::mutex> lock(mtx);
        cond_not_empty.wait(lock, [this]{ return !buffer.empty(); });
        T item = buffer.front();
        buffer.pop();
        cond_not_full.notify_one();
        return item;
    }

    // 可选：非阻塞写
    bool try_write(const T& item) {
        std::lock_guard<std::mutex> lock(mtx);
        if (buffer.size() >= max_size) return false;
        buffer.push(item);
        cond_not_empty.notify_one();
        return true;
    }

    // 可选：非阻塞读
    bool try_read(T& item) {
        std::lock_guard<std::mutex> lock(mtx);
        if (buffer.empty()) return false;
        item = buffer.front();
        buffer.pop();
        cond_not_full.notify_one();
        return true;
    }
};

使用示例（生产者-消费者）

#include <iostream>
#include <thread>
#include <string>

int main() {
    ThreadPipe<std::string> pipe(5);

    // 生产者线程
    std::thread producer([&pipe](){
        for (int i = 0; i < 10; ++i) {
            pipe.write("Message " + std::to_string(i));
            std::cout << "Produced: Message " << i << std::endl;
        }
    });

    // 消费者线程
    std::thread consumer([&pipe](){
        for (int i = 0; i < 10; ++i) {
            std::string msg = pipe.read();
            std::cout << "Consumed: " << msg << std::endl;
        }
    });

    producer.join();
    consumer.join();
}

✅ 输出示例：

Produced: Message 0
Consumed: Message 0
Produced: Message 1
Consumed: Message 1
...

4 面试常见问题

  1. ​​嵌入式系统中，管道是什么？它的基本原理是什么？​​

    管道是一种​​单向的进程间通信机制​​，它将一个进程的输出直接连接到另一个进程的输入。其基本原理是内核提供的一个​​缓冲区​​，数据以​​先进先出​​的方式从写端流向读端。在嵌入式系统中，管道常用于任务间的数据流传递，例如日志收集或命令分发。

  2. ​​匿名管道和命名管道（FIFO）的主要区别是什么？​​

    两者的核心区别如下表所示：

特性

匿名管道

命名管道 (FIFO)

​​存在形式与访问​​

内存缓冲区，无文件实体，仅用于​​有亲缘关系​​的进程（如父子进程）。

文件系统中的特殊文件，有路径名，可用于​​任意进程​​间通信。

​​生命周期​​

随创建它的进程结束而销毁。

独立于进程存在，除非显式删除（如unlink）。

​​创建方式​​

通过 pipe()系统调用创建。

通过 mkfifo()函数或命令创建。

4.1 管道编程与API

  1. ​​创建和使用一个匿名管道的基本步骤是什么？请写出关键代码。​​

    基本步骤包括：创建管道、创建子进程、关闭不需要的端口、进行读写操作，最后关闭管道。

    #include <unistd.h>
#include <stdio.h>
int main() {
    int pipefd[2];
    pid_t pid;
    char buf[100];
    if (pipe(pipefd) == -1) { /* 错误处理 */ }
    pid = fork();
    if (pid == 0) {
        // 子进程：关闭写端，读取数据
        close(pipefd[1]);
        read(pipefd[0], buf, sizeof(buf));
        printf("Child received: %s\n", buf);
        close(pipefd[0]);
    } else {
        // 父进程：关闭读端，写入数据
        close(pipefd[0]);
        write(pipefd[1], "Hello Pipe!", 12);
        close(pipefd[1]);
    }
    return 0;
}

  2. ​​管道的open操作有什么特殊的阻塞行为？​​

    对于命名管道，默认的open模式是阻塞的。如果一个进程以​​只读方式​​打开一个尚无写端的FIFO，该进程将被阻塞，直到另一个进程以​​只写方式​​打开这个FIFO。反之，以只写方式打开一个尚无读端的FIFO也会发生阻塞。可以使用 O_NONBLOCK标志设置为非阻塞模式。

4.2 管道核心特性与行为

  1. ​​管道的读写操作是阻塞的吗？什么是原子性写入？​​

    • ​​阻塞行为​​：默认情况下，管道读写是阻塞的。从​​空管道​​读取会阻塞，直到有数据写入；向​​满管道​​写入会阻塞，直到有空间读出。

    • ​​原子性写入​​：当多个进程同时向一个管道写入数据时，如果​​单次写入的数据量小于 PIPE_BUF​​（一个系统常量，通常为4KB），操作系统能保证这次写入是原子的，即数据块不会与其他写入进程的数据交织在一起。

  2. ​​如果管道的读端关闭后，写端继续写入会发生什么？​​

    在这种情况下，操作系统会向写进程发送一个 SIGPIPE信号。该信号的​​默认行为是终止进程​​。因此，在严谨的程序中，需要处理或忽略 SIGPIPE信号，并检查 write操作的返回值（会返回-1，并设置 errno为 EPIPE）。

4.3 管道在嵌入式系统中的应用与设计

  1. ​​在嵌入式多任务环境中，管道通常用于什么场景？​​

    管道在嵌入式系统中典型的应用场景包括：

    • ​​生产者-消费者模型​​：一个任务（生产者）产生数据（如传感器读数），通过管道发送给另一个任务（消费者）进行处理。

    • ​​日志系统​​：多个任务将日志信息写入一个公共管道，由一个专用的日志任务统一读取并写入存储设备，保证日志顺序且不阻塞主要业务逻辑。

    • ​​命令/消息分发​​：一个主控任务通过不同的管道向各个工作任务发送控制命令或消息。

  2. ​​如何用管道实现双向进程间通信？​​

    单向管道只能实现单向通信。要实现双向通信，需要​​创建两个管道​​，一个用于A进程写、B进程读，另一个用于B进程写、A进程读。每个进程都需要在初始化时关闭自己不需要的端口。

  3. ​​在资源受限的嵌入式系统中，使用管道需要注意什么？​​

    • ​​缓冲区大小​​：管道缓冲区容量有限，需注意避免写端过快导致写阻塞，或读端过慢导致缓冲区满。

    • ​​优先级反转​​：在高优先级任务等待低优先级任务写入数据的系统中，可能会发生优先级反转问题，需结合优先级继承等机制进行设计。

    • ​​内存开销​​：每个管道都会占用系统内存，在极度资源受限的场景下需权衡使用。

    • ​​错误处理​​：必须妥善处理管道读写错误、对方进程异常退出等情况，确保系统健壮性。

4.4 调试与进阶知识

  1. ​​如何调试管道通信中出现的问题？​​

    • 使用 printf或日志在关键位置（如打开、关闭、读写前后）打印状态信息和文件描述符。

    • 检查所有系统调用（pipe, fork, open, read, write, close）的返回值，进行错误处理。

    • 使用 ls -l检查命名管道文件是否已正确创建，权限是否合适。

    • 在复杂场景下，可使用 strace工具跟踪进程的系统调用，观察管道的实际行为。

  2. ​​管道与其他IPC机制（如消息队列、共享内存）相比，有什么优势和劣势？​​

    • ​​优势​​：​​简单易用​​，接口清晰；​​自带同步​​，读写操作自动阻塞等待；数据按顺序流动，保证​​顺序性​​。

    • ​​劣势​​：​​传输效率​​通常低于共享内存，因为数据需要在内核和用户空间之间拷贝；​​通信能力受限​​，一般为单向通信，且缺乏消息边界概念（字节流）。

# c语言 # c++ # 开发语言
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

SeedVR2终极指南：如何用单步扩散模型实现专业级视频修复

还在为老旧视频的模糊画质而烦恼吗？面对抖动严重的监控录像或褪色的家庭影像，你是否曾希望有一种简单高效的修复方案？SeedVR2正是为解决这些痛点而生的一站式视频修复工具。作为字节跳动推出的先进视频修复模型，它能够在单步推理中实现专业级的视频质量提升，彻底改变了传统视频修复的工作流程。## 核心价值：为什么选择SeedVR2进行视频修复？**传统视频修复的三大瓶颈**：1. **计算成本高

avatar AI Agent技术社区

深度解析Amlogic S9xxx电视盒子Armbian系统：从闲置设备到Linux服务器的终极实战指南

你是否拥有一台闲置的Amlogic S9xxx系列电视盒子？想让它摆脱单一的视频播放功能，变身为功能强大的Linux服务器、开发平台或家庭媒体中心？本指南将为你详细解析如何通过Armbian系统实现这一转变，让你的电视盒子重获新生，成为高性能的Linux设备。Armbian系统基于Debian/Ubuntu构建，专为ARM芯片优化，提供了完整的Linux生态支持。## 🎯 核心价值与独特优势

avatar AI Agent技术社区

CANN/runtime Event管理API

本章节描述 CANN Runtime 的 Event 管理接口，用于事件的创建、记录、同步、计时及 IPC 跨进程共享。- [`aclError aclrtCreateEvent(aclrtEvent *event)`](#aclrtCreateEvent)：创建Event，创建出来的Event可用于统计两个Event之间的耗时、多Stream之间的任务同步等场景。- [`aclError

avatar AI Agent技术社区