1.匿名管道

（1）.匿名管道的原理

（2）.pipe接口的使用

如果只写不读（求管道的大小）

（3）.匿名管道五个特点

（4）.匿名管道的四种情况

3.命名管道

（1）.命名管道的原理/实质

（2）.在命令行中创建使用匿名管道

（3）.代码中创建使用命名管道

1）.同时编译多个文件，makefile

2）.mkfifo()函数

3）.e.g.

（4）.命名管道注意事项

4.匿名管道和命名管道的区别与联系

1.匿名管道

（1）.匿名管道的原理

1.创建子进程的时候，PCB也是要自己有一份的，同样里面的files_struct也是要自己独立有一份的（这些都属于进程的数据结构，进程是具有独立性的）

2.而通过文件描述符找到的struct_file则是不需要给子进程拷贝一份的，因为这个是属于文件的，和创建进程没有关系。

3.调用write方法的时候，是系统调用，会先将数据放在文件的内核缓冲区（不是C语言层面的缓冲区），底层定期的将缓冲区中的内容写到磁盘中。

可以看出，父进程和子进程可以看到的公共区域是struct_file，这里也就可以进行进程间通信了。struct_file里面有文件缓冲区，一个进程往缓冲区里面写数据，一个进程往缓冲区里面读数据，这就是匿名管道的原理，一种基于文件的通信方式

（2）.pipe接口的使用

pipefd[2]:是一个输出性参数!我们想通过这个参数读取到打开的两个fd/

int pipe(int pipefd[ 2]);

pipe[0]表示读取端，pipe[1]表示写入端

e.g.:

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

int main()
{
    int pipe_fd[2] = {0};

    if (pipe(pipe_fd) < 0)
    {
        perror("pipe");
        return 1;
    }
    printf("%d, %d\n", pipe_fd[0], pipe_fd[1]); // 输出3,4

    pid_t id = fork();
    if (id < 0)
    {
        perror("fork");
        return 2;
    }
    else if (id == 0)
    { 
        // 让父进程读取，子进程写入
        close(pipe_fd[0]); // 关掉读取端

        char c = 'x';
        int count = 0;

        while (1)
        {
            write(pipe_fd[1], &c, 1);
            // sleep(1);
            count++;
            printf("write: %d\n", count);
        }

        close(pipe_fd[1]);
        exit(0);
    }
    else
    { 
        // 父进程读
        close(pipe_fd[1]); // 关掉写入端

        char buffer[64];
        while (1)
        {
            // sleep(100);让父进程不读，用于模拟计算管道的大小
            sleep(1);
            size_t size = read(pipe_fd[0], buffer, sizeof(buffer) - 1); // 默认都是0，最后留一个位置作为\0
            // 如果read返回值为0，意味着子进程关闭文件描述符了，相当于读到文件结尾了
            if (size > 0)
            {
                buffer[size] = 0;
                printf("parent get messge from child# %s\n", buffer);
            }
            else if (size == 0)
            {
                printf("pipe file close, child quit!\n");
                break;
            }
            else
            {
                break;
            }
        }

        int status = 0;
        if (waitpid(id, &status, 0) > 0)
        {
            printf("child quit, wait success!, sig: %d\n", status & 0x7F);
        }
        close(pipe_fd[0]);
    }
    return 0;
}

这里是子进程写入，父进程读取，子进程每1s写入一个x，父进程每1s读取一个x。

如果只写不读（求管道的大小）

所以如果我们需要知道管道的大小，写一个程序算一下就行。

这里管道的大小是64KB

方法：将之前代码中的父进程（读取端）sleep（100）,让自进程一直写，最后我们会发现它停止在65536，因为管道满了，写端被阻塞，需要等读端来读

（3）.匿名管道五个特点

1.管道是一个只能单向通信的通信信道，这里父进程有一个读端和一个写端，这样子进程继承下去才可以读写，如果只有一个读端，那么子进程也就只能读了。因为是单向通信，所以父进程一次只能开一个写端或者一个读端，子进程也是。（要么父写子读，要么子写父读）

2.管道是面向字节流的（也就是读取数据的时候只有字节的概念，你让我读多少个字节就读多少个，具体哪部分有用等读进来到用户层面处理）

3.管道自带同步机制（写端写满了管道，就不写了，等对方读；读端读完了管道内容，就不读了，等对方写）

原子性写入/读取（如果写满之后，只读一点点数据，是不能唤醒对方来写的，要读一定的数据量以后，才能唤醒对方来写，这个数据量就是PIPE_BUF。同理只写一点点数据，也无法唤醒对方来读）

当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

4.仅限于父子间通信（具有血缘关系的进程进行进程间通信）

5.管道的生命周期是随进程的（进程结束后，管道作为文件会被OS自动关闭，即使没有close）

（4）.匿名管道的四种情况

管道的四种情况：

当没有数据可读时

O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。

//O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。（非阻塞式）

当管道满的时候

O_NONBLOCK disable： write调用阻塞，直到有进程读走数据

//O_NONBLOCK enable：调用返回-1，errno值为EAGAIN（非阻塞式）

如果所有管道写端对应的文件描述符被关闭，则read返回0，表明读到文件结尾
如果所有管道读端对应的文件描述符被关闭，则write操作会让OS给目标进程发送信号SIGPIPE，终止写入进程

----（我们可以验证，父进程读，子进程写入；父进程关闭读端，此时操作系统会向进行写操作的进程发出SIGPIPE信号，从而使子进程异常终止。此时父进程通过waitpid获取子进程的status，从status中获取退出码和退出信号）

3.命名管道

为了解决匿名管道只能父子通信，引入了命名管道。

命名管道让两个毫不相关的进程进行通信。

（1）.命名管道的原理/实质

进程是具有独立性的

->进程通信的成本其实比较高

->必须先解决一个问题

->让不同的进程先要看到同一份资源(内存文件，内存，队列)[一定需要OS来提供]

->pipe本质:是通过子进程继承父进程资源的特性，达到一个让不同的进程看到同一份资源

如果是两个不相关的进程，我们要通信可以创建一个文件来做到两个进程间的通信（我们标识一个磁盘文件的时候，可以用路径/文件名来标识，因为操作系统的文件结构是树形结构，每个叶子结点向上追溯到根节点的路径是唯一的）

A进程把内容写入文件temp.txt，B进程从temp.txt中读取，这就实现了进程间通信。但是这种方法很慢，我们可以将文件放在内存中，不要放在磁盘中，这样就会更加快速，A和B同时打开这个放在内存中的文件

所以我们需要一个文件，

1.它被打开的时候，不会把数据刷新到磁盘里，而是保存在内存中

2.在内存中也有一个文件名，方便两个进程通过路径+文件名看到这个文件。

这样的文件就是命名管道（命名的意思是必须有名字，为了让两个进程可以通过同一个路径+文件名找到同一个文件）

（2）.在命令行中创建使用匿名管道

p表示管道文件

使用mkfifo创建一个命名管道，会出现一个类型为p的文件，也就是我们创建的命名管道

一个进程往命名管道中写入内容，另一个进程可以从管道文件中读取数据，这里写了一个shell脚本

while:; do echo "zebra的数据"; sleep 1; done > namedPipe

（3）.代码中创建使用命名管道

1）.同时编译多个文件，makefile

all:client server

client:client.c
	gcc -o $@ $^

server:server.c
	gcc -o $@ $^

.PHONY:clean
clean:
	rm -f client server fifo

2）.mkfifo()函数

int mkfifo(const char *filename,mode_t mode);

filename表示管道的文件名（可以加上路径），mode表示创建的管道文件的权限

1.在server.c里面调用mkfifo创建命名管道文件，权限设置为0666（注意这里需要设置一下umask，否则会受到系统默认umask的影响，默认是002）

如果创建失败（比如同名管道文件已经存在），就打印出错误信息。

#define MY_FIFO "./fifo"
    umask(0);
    if(mkfifo(MY_FIFO, 0666) < 0){
        perror("mkfifo");
        return 1;
    }
    //只需要文件操作即可，打开文件读
    int fd = open(MY_FIFO, O_RDONLY);
    if(fd < 0){
        perror("open");
        return 2;
    }

2.一旦我们有了命名管道。此时，我们只需要让通信双方按照文件操作即可（推荐使用系统调用接口，没有用户层缓冲区的问题）

3.在client.c里面不需要再创建管道文件，直接打开文件开写就行。

4.因为命名管道也是基于字节流的，所以实际上，信息传递的时候，是需要通信双方定制“协议的”，这里暂时不考虑协议相关问题。

3）.e.g.

实现一个让client从键盘读入数据，并向管道中写入内容，让server从命名管道中读取文件内容。

这里在server里面加了一些处理逻辑，如果server读到的内容是show，就创建子进程执行ls -l命令，如果读到的内容是run，就创建子进程执行sl命令；如果读到的是其他内容，就直接将内容打印出来。

server.c:

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

#define MY_FIFO "./fifo"
int main()
{
    umask(0);
    if(mkfifo(MY_FIFO, 0666) < 0){
        perror("mkfifo");
        return 1;
    }

    //只需要文件操作即可
    int fd = open(MY_FIFO, O_RDONLY);
    if(fd < 0){
        perror("open");
        return 2;
    }

    //业务逻辑,可以进行对应的读写了
    while(1){
        char buffer[64] = {0};
        sleep(1);
        ssize_t s = read(fd, buffer, sizeof(buffer)-1); //键盘输入的时候，\n也是输入字符的一部分
        if(s > 0){
            //success
            buffer[s] = 0;
            if(strcmp(buffer, "show") == 0){  //如果输入show，创建子进程执行ls -l命令
                if(fork() == 0){
                    execl("/usr/bin/ls", "ls", "-l", NULL);
                    exit(1);
                }

                waitpid(-1, NULL, 0);
            }
            else if(strcmp(buffer, "run") == 0){  //如果输入run，创建子进程执行sl命令
                if(fork() == 0){
                    execl("/usr/bin/sl", "sl", NULL);
                }
                waitpid(-1, NULL, 0);
            }
            else{
                printf("client# %s\n", buffer);
            }
        }
        else if(s == 0){
            //peer close
            printf("client quit ...\n");
            break;
        }
        else{
            //error
            perror("read");
            break;
        }
    }

    close(fd);
    return 0;
}

client.c:

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

#define MY_FIFO "./fifo"
int main()
{
    //用不用在创建fifo?? 我只要获取即可
    int fd = open(MY_FIFO, O_WRONLY); //不需要O_CREAT
    if(fd < 0){
        perror("open");
        return 1;
    }

    //业务逻辑
    while(1){
        printf("请输入# ");
        fflush(stdout);
        char buffer[64] = {0};
        //先把数据从标准输入拿到我们的client进程内部
        ssize_t s = read(0, buffer, sizeof(buffer)-1);
        if(s > 0){
			// //获取到数据以后，需要把最后一个字符置为\0（‘\0’就是0，这里去掉最后一个字符，并设置为\0）
            buffer[s-1] = 0;
            printf("%s\n", buffer);

            //拿到了数据
            write(fd, buffer, strlen(buffer)); //这里不需要-1，因为是写入数据，操作系统不需要最后/0作为标识符，C语言中的字符串才需要
        }
    }

    close(fd);
    return 0;
}

运行结果：