Linux_进程间通信_管道

匿名管道：

1.管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。

2.管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。

3.一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。

4.通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。

5.在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。

6.从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用 lseek() 来随机的访问数据。

7.匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。

8.管道不属于文件系统，存放在内存中。

使用：

①创建匿名管道： int pipe(int pipefd[2]);

​ 成功返回0，失败返回-1

②查看管道缓冲大小命令： ulimit –a

③查看管道缓冲大小函数： long fpathconf(int fd, int name);

​ name：_PC_PIPE_BUF

管道fd和套接字fd一样可以进行close、read、write操作，pipefd[0]为读端，pipefd[1]为写端。

在fork()之前创建管道，这样父子进程用同一个管道fd。

使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）

1.所有的指向管道写端的文件描述符都关闭了（管道写端引用计数为0），有进程从管道的读端读数据，那么管道中剩余的数据被读取以后，再次read会返回0，就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了（管道的读端引用计数为0），这个时候有进程向管道中写数据，那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。

4.如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候再次write会阻塞，直到管道中有空位置才能再次写入数据并返回。

总结：

读管道：

管道中有数据，read返回实际读到的字节数。

管道中无数据：写端被全部关闭，read返回0（相当于读到文件的末尾）；写端没有完全关闭，read阻塞等待

写管道：

管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）

管道读端没有全部关闭：管道已满，write阻塞；管道没有满，write将数据写入，并返回实际写入的字节数

设置管道为非阻塞：

int flags = fcntl(pipefd[0], F_GETFL); // 获取原来的flag

flags |= O_NONBLOCK; // 修改flag的值

fcntl(pipefd[0], F_SETFL, flags); // 设置新的flag

关闭读管道：close(pipefd[0])

关闭写管道：close(pipefd[1])

write(pipefd[1], “abc”,3);

read(pipefd[0], buf,3);

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <cstring>
#include <fcntl.h>

int main()
{
    int status = 0;
    // 创建管道，0读1写
    int pipefd[2];
    int ret = pipe(pipefd);
    if (ret < 0)
    {
        perror("pipe");
    }
    // 设置管道为非阻塞
    for (int i = 0; i < 2; i++)
    {
        int flags = fcntl(pipefd[i], F_GETFL, 0);
        if (flags < 0)
        {
            printf("socket et_non_blocking error: errno=%d, errmsg=%s", errno, strerror(errno));
            return 1;
        }
        flags |= O_NONBLOCK;
        if (fcntl(pipefd[i], F_SETFL, flags) < 0)
        {
            printf("socket set_non_blocking error: errno=%d, errmsg=%s", errno, strerror(errno));
            return 1;
        }
    }

    int pid = fork();
    if (pid == -1)
    {
        perror("fork");
        return 1;
    }
    else if (pid == 0)
    {
        printf("this is child process, pid=%d\n", getpid());
        close(pipefd[1]);
        char readbuf[1024] = {0};
        ret = read(pipefd[0], readbuf, sizeof(readbuf));
        if(ret < 0){
            perror("read");
        }
        else printf("This message is from father: %s\n", readbuf);
        close(pipefd[0]);
    }
    else
    {
        close(pipefd[0]);
        char writebuf[1024] = "Hello, Child!";
        ret = write(pipefd[1], writebuf, sizeof(writebuf));
        if(ret < 0){
            perror("write");
        }
        close(pipefd[1]);

        ret = wait(&status);    //等待回收子进程
        if (ret == -1)
        {
            perror("wait");
            return 1;
        }

        if (WIFEXITED(status))
        {
            printf("father wait child exit\n");
        }
        else if (WIFSIGNALED(status))
        {
            printf("child process exit wrong\n");
        }
        else if (WIFSTOPPED(status))
        {
            printf("child process %d is stopped\n", WSTOPSIG(status));
        }
    }

    return 0;
}

有名管道：

匿名管道只能用于亲缘关系的进程间通信，因此创建了有名管道FIFO。

FIFO提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。

一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/O系统调用了（如read()、write()和close()）。

与管道一样，FIFO也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO 的名称也由此而来：先入先出。

FIFO在文件系统中作为一个特殊文件存在，但其内容存放在内存中。

当使用FIFO的进程退出后，FIFO文件将继续保存。

使用：sys/stat.h

通过命令创建有名管道： mkfifo 名字

通过函数创建有名管道：int mkfifo(const char *pathname, mode_t mode);

一旦使用 mkfifo 创建了一个 FIFO，就可以使用 open 打开它，常见的文件I/O 函数都可用于 fifo。如：close、read、write、unlink 等。

mode:0664

FIFO 严格遵循先进先出（First in First out），对管道及 FIFO 的读总是从开始处返回数据，对它们的写则把数据添加到末尾。

不支持诸如 lseek() 等文件定位操作。

有名管道的注意事项：

​ 1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道

​ 2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道

读管道：

管道中有数据，read返回实际读到的字节数

管道中无数据：管道写端被全部关闭，read返回0，（相当于读到文件末尾）；写端没有全部被关闭，read阻塞等待

写管道：

管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）

管道读端没有全部关闭：管道已经满了，write会阻塞；管道没有满，write将数据写入，并返回实际写入的字节数。

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

int main()
{
    int status = 0;
    // 创建有名管道
    int ret = access("fifo", 0664); // 判断管道是否存在
    if (ret == -1)
    {
        printf("管道不存在，创建管道\n");

        ret = mkfifo("fifo", 0664);

        if (ret == -1)
        {
            perror("mkfifo");
        }
    }

    int pid = fork();
    if (pid == -1)
    {
        perror("fork");
        return 1;
    }
    else if (pid == 0)
    {
        printf("this is child process, pid=%d\n", getpid());
        int fd = open("fifo", O_RDONLY);
        if (fd == -1)
        {
            perror("open");
        }

        char readbuf[1024] = {0};
        ret = read(fd, readbuf, sizeof(readbuf));
        if (ret < 0)
        {
            perror("read");
        }
        else
            printf("This message is from father: %s\n", readbuf);
        close(fd);
    }
    else
    {
        int fd = open("fifo", O_WRONLY);
        if (fd == -1)
        {
            perror("open");
        }

        char writebuf[1024] = "Hello, Child!";
        ret = write(fd, writebuf, sizeof(writebuf));      //若无只读打开的进程则阻塞
        if(ret <= 0){
            perror("write");
        }
        close(fd);

        ret = wait(&status);
        if (ret == -1)
        {
            perror("wait");
            return 1;
        }

        if (WIFEXITED(status))
        {
            printf("father wait child exit\n");
        }
        else if (WIFSIGNALED(status))
        {
            printf("child process exit wrong\n");
        }
        else if (WIFSTOPPED(status))
        {
            printf("child process %d is stopped\n", WSTOPSIG(status));
        }
    }

    return 0;
}