Linux系统调用之pipe函数

前言

如果，想要深入的学习Linux系统调用函数pipe了话，还是需要去阅读Linux系统中的帮助文档的。
具体输入命令：

man 2 pipe

即可查阅到完整的资料信息。

pipe函数

在Linux中，pipe() 是一个底层系统调用，用于创建管道(pipe)。管道是用于进程间通信的一种简单机制，通过pipe()函数可以创建一个匿名的、单向的管道，可以在不同的进程之间传递数据。pipe()函数的原型如下：

#include <unistd.h> //使用函数需导入此头文件
int pipe(int pipefd[2]);
1
2

pipefd是一个两个元素的整型数组，它是一个传出参数，用于存放管道的读写文件描述符。

• 其中pipefd[0]为管道读端，pipefd[1]为管道写端。这两个文件描述符可以像其他文件描述符一样进行读写操作。

• 管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞

• 注意：（匿名）管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）

以下是一个简单的示例，演示了如何使用pipe()函数创建一个管道，并在子进程和父进程之间传递数据：

代码示例：子进程向父进程传达消息

/*
    #include <unistd.h>
    int pipe(int pipefd[2]);
        功能：创建一个匿名管道，用来进程间通信。
        参数：int pipefd[2] 这个数组是一个传出参数。
            pipefd[0] 对应的是管道的读端
            pipefd[1] 对应的是管道的写端
        返回值：
            成功 0
            失败 -1

    管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞

    注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
*/

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    int pipefd[2];
    int retPipe = pipe(pipefd);
    if (retPipe == -1)
    {
        perror("pipe");
        exit(0);
    }

    int pid = fork();

    if (pid > 0)
    {
        close(pipefd[1]); // 关闭父进程写端
        char buf[1024];

        ssize_t len = read(pipefd[0], buf, sizeof(buf)); // 读取子进程写入的信息

        if (len == -1)
        {
            perror("read");
            exit(0);
        }

        buf[len] = '\0'; // 确保字符串以 null 结尾

        printf("我是父进程，我的进程号是：%d，正在接受来自子进程的信息…\n", getpid());
        printf("%s\n", buf);
    }
    else if (pid == 0)
    {

        close(pipefd[0]); // 关闭子进程读端
        char buf[1024];
        sprintf(buf, "%s%d", "我是子进程，我的进程号是：", getpid());
        ssize_t len = write(pipefd[1], buf, strlen(buf)); // 写入子进程信息
        if (len == -1)
        {
            perror("write");
            exit(0);
        }
    }
    else
    {
        perror("fork");
        return -1;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

输出结果：

nowcoder@nowcoder:~/Linux/lession22$ ./pipe
我是父进程，我的进程号是：2453，正在接受来自子进程的信息…
我是子进程，我的进程号是：2454
1
2
3

使用 ulimit –a 命令 查看管道缓冲大小命令

• “ulimit” 是一个用于控制 shell 进程资源限制的命令，在 Linux 系统中经常用于限制某个用户或进程的资源使用。“-a” 是 ulimit 命令的一个选项，表示显示所有当前限制值的详细信息。当在终端中输入 “ulimit -a” 命令后，将会列出所有的资源限制信息

core file size          (blocks, -c) 0 # shell 进程生成的 core 文件的大小限制，如果为 0 表示不限制
data seg size           (kbytes, -d) unlimited # 数据段的最大长度
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 15524
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1048576
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 15524
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

其中pipe size (512 bytes, -p) 8这一行表示管道（pipe）的大小限制。管道是一种进程间通信（IPC）机制，允许一个进程的输出成为另一个进程的输入。这里的数字“8”表示的是管道缓冲区大小限制的倍数。由于括号内提到了每单位的大小为512字节，所以这里的管道大小限制为 8 * 512 = 4096字节。

这意味着在使用管道进行进程间通信时，缓冲区最多可以容纳4096字节的数据。当管道的缓冲区被填满时，写入管道的进程将被阻塞，直到另一个进程从管道中读取数据为止。