一、进程间通信的概念

进程是一个独立的资源分配单元，不同进程（通常指用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。    但是进程不是孤立的，不同的进程之间需要进行信息的交互和状态的传递等，因此需要进程间通信。（IPC: Inter Processes Communication）

1.1 进程间通信的目的：

1、 数据传输：一个进程需要将它的数据发送给另一个进程

2、通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种
事件（如进程终止时要通知父进程）

3、资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同
步机制

4、进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制
进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

1.2 进程通信的方式：

 

二、匿名管道通信（管道通信）

管道 pipe 也叫无名（匿名）管道，它是 UNIX 系统 IPC（进程间通信）的最古老形式，所有的 UNIX 系统都支持这种通信机制。
 

例如：

统计一个目录中文件的数目命令： ls | wc –l，为了执行该命令， shell 创建了两个进程来分别执行 ls 和 wc。  其中 | 是管道符。

2.1  匿名管道的特点：

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

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

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

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

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

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

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

8、匿名管道 的 缓冲数据结构 是 环形队列。

2.2  使用 匿名管道 进行 进程间通信，示意图如下：

 

 2.3 使用匿名管道 进行进程间通信的原理：

如上的示意图：

        在创建子进程的时候，子进程会拷贝，与父进程相同的文件描述符表。  父进程 只要关闭 写端（或读端）的文件描述符 ， 子进程只要关闭 读端 （或写端）的文件描述符，就可以实现 父进程 向 子进程发送数据 ， 或者 子进程向父进程发送数据 的 进程间通信。   这也是匿名管道  半双工的含义。

三、匿名管道的代码示例

Note :  可以使用 man 2 pipe 查看帮助文档

创建匿名管道
#include <unistd.h>
int   pipe(int pipefd[2]);

功能：创建一个匿名管道，用来进程间通信
参数：int pipefd[2] ,这个数组是 传出参数。 
            pipefd[0] 对应管道的 读端
            pipefd[1] 对应管道的 写端
 返回值：
            成功   返回0
            失败   返回-1

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

查看管道缓冲大小函数
#include <unistd.h>
long  fpathconf(int fd, int name);
 

注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
    
管道  默认是阻塞的，如果管道中没有数据，read阻塞，如果管道满了，write阻塞。
 

3.1 匿名管道通代码示例：

实现子进程向父进程发送数据的 进程间通信：

/*
    #include <unistd.h>

    int pipe(int pipefd[2]);
        功能：创建一个匿名管道，用来进程间通信
        参数：int pipefd[2] ,这个数组是传出参数。 
            pipefd[0] 对应管道的读端
            pipefd[1] 对应管道的写端
        返回值：
            成功  返回0
            失败  返回-1
    注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
    
    管道默认是阻塞的，如果管道中没有数据，read阻塞，如果管道满了，write阻塞。

*/

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

//子进程发送数据给父进程，父进程读取到数据输出
int main()
{
    //需要在 fork 之前创建管道 ， 这样子进程与父进程 对应相同的管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();

    if(pid>0)
    {
        printf("I am parent process,pid:%d\n",getpid());
        //父进程

        //关闭写端
        close(pipefd[1]);
        //从管道的读取端读取数据
        char buf[100];
        while(1)
        {
            //read会阻塞，进行读取数据
            int len = read(pipefd[0],&buf,sizeof(buf));
            printf("parent recv : %s ,pid:%d \n",buf,getpid());

            //向管道中写数据
            //char* str = "Hello ,I am parent";
            //write(pipefd[1],str,strlen(str));
            //sleep(1);
        }
        

    }else if(pid == 0)
    {
        printf("I am child process,pid:%d\n",getpid());
        //子进程 关闭读端
        close(pipefd[0]);
        while(1)
        {
             //子进程
            char* str = "Hello ,I am child ";
            write(pipefd[1],str,strlen(str));
            sleep(1);

             //read会阻塞，进行读取数据
            //char buf[100];
            //int len = read(pipefd[0],&buf,sizeof(buf));
            //printf("child recv : %s ,pid:%d \n",buf,getpid());
        }
       
    }

}

执行结果：

3.2 获取管道的大小：

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

int main()
{
    int pipefd[2];
    int ret = pipe(pipefd);
    //get configuration for files
    long size = fpathconf(pipefd[0],_PC_PIPE_BUF);
    printf("pipe size:%ld\n",size);
    return 0;
}

执行结果：

也就是说，默认的匿名管道的大小是 4K 。

3.3 实现 ps aux | grep xxx 父子进程之间通信：

/*
    实现 ps aux | grep xxx   父子进程间通信
    子进程：ps aux，子进程结束后，将数据发送给父进程
    父进程：获取到数据，过滤
    pipe()
    execlp() 执行子进程
    子进程将标准输出重定向到父进程，管道的写端 dup2

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


int main()
{
    //创建一个 匿名管道
    int fd[2];
    int ret = pipe(fd);
    if(ret == -1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();

    if(pid>0)
    {
        //父进程
        //关闭写端
        close(fd[1]);
        //从管道中读取
        char buf[1024];
        int len = -1;
        while((len = read(fd[0],buf,sizeof(buf)-1))>0)
        {
            //过滤数据输出
            printf("%s",buf);
            memset(buf,0,sizeof(buf));
        }
        //回收子进程的资源
        wait(NULL);

    }else if(pid == 0)
    {
        //子进程
        //关闭读端
        close(fd[0]);
        //文件描述符重定向  stdout_fileno -> fd[1] 重定向到 fd[1]
        dup2(fd[1],STDOUT_FILENO);
        //执行 ps aux
        execlp("ps","ps","aux",NULL);  //因为管道的大小有限定，只有4k，如果多余4K,就不会写进去。
        perror("execlp");
        exit(0);

    }else{
        perror("fork");
        exit(0);

    }

    return 0;
}

执行结果：

 

3.4  设置非阻塞管道：

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

/*
    设置管道非阻塞
    fcntl(fd[0],F_GETFL); //获取原来的flag
    flags |= O_NONBLOCK;  //修改flag的值
    fcntl(fd[0],F_SETFL,flags);//设置新的flag
*/

//子进程发送数据给父进程，父进程读取到数据输出
int main()
{
    //需要在 fork 之前创建管道 ， 这样子进程与父进程 对应相同的管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();

    if(pid>0)
    {
        printf("I am parent process,pid:%d\n",getpid());
        //父进程

        //关闭写端
        close(pipefd[1]);
        //从管道的读取端读取数据
        char buf[100];
        int flags = fcntl(pipefd[0],F_GETFL); //获取原来的flag
        flags |= O_NONBLOCK;  //修改flag的值
        fcntl(pipefd[0],F_SETFL,flags);//设置新的flag

        while(1)
        {
            //read会阻塞，进行读取数据
            int len = read(pipefd[0],&buf,sizeof(buf));
            printf("len :%d\n",len);
            printf("parent recv : %s ,pid:%d \n",buf,getpid());
            memset(buf,0,sizeof(buf));
            sleep(1);

        }
        

    }else if(pid == 0)
    {
        printf("I am child process,pid:%d\n",getpid());
        //子进程 关闭读端
        close(pipefd[0]);
        while(1)
        {
             //子进程
            char* str = "Hello ,I am child ";
            write(pipefd[1],str,strlen(str));
            sleep(5);

        }
       
    }

}

执行结果：

3.5 管道的读写特点总结：

使用管道时，需要注意以下几种特殊的情况, 匿名管道，默认是阻塞的：

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

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

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

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

总结：

读管道：

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

管道中无数据：

       写端被全部关闭，read返回0，相当于读到文件的末尾

       写端没有完全关闭，read阻塞等待

写管道：

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

管道读端没有全部关闭：

       管道已满，write阻塞

       管道没满，write将数据写入，并返回实际写入的字节数

设置管道 非阻塞：   对文件描述符进行设置。

四、有名管道 （FIFO）

        匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道（FIFO），也叫 命名管道、 FIFO文件。

4.1 有名管道的特点：

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

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

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

4.2  有名管道与匿名管道的区别：

有名管道（FIFO)和匿名管道（pipe），不一样的地方在于：

1、FIFO 在文件系统中作为一个特殊文件存在，但 FIFO 中的内容却存放在内存中

2、当使用 FIFO 的进程退出后， FIFO 文件将继续保存在文件系统中以便以后使用

3、FIFO 有名字，不相关的进程可以通过打开有名管道进行通信

4.3 有名管道的注意事项：

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

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

读管道：

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

管道中无数据：

        管道写端被全部关闭，read返回0 ，相当于读到文件末尾

        写端没有全部被关闭，read阻塞等待

写管道：

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

管道读端没有全部关闭：

        管道已经满了，write会阻塞

        管道没有满，write将数据写入，并返回实际写入的字节数

4.4 代码示例：

1. 创建 有名管道

关于 mkfifo函数使用说明，可以使用 man  3  mkfifo 命令查看帮助文档。

创建fifo文件

1.通过命令： mkfifo 名字

2.通过函数：int mkfifo(const char *pathname, mode_t mode);

 #include <sys/types.h>

 #include <sys/stat.h>

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

 参数：

     - pathname: 管道名称的路径

     - mode: 文件的权限 和 open 的 mode 是一样的是一个八进制的数

  返回值：

        成功返回0，失败返回-1，并设置错误号

2.创建有名管道，并向管道写数据：

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


//向管道中写数据
int main()
{
    //1.判断文件是否存在
    int ret = access("fifo",F_OK);
    if(ret ==-1)
    {
        printf("管道不存在，创建管道\n");
        //2.创建管道文件
        ret = mkfifo("fifo",0664);

        if(ret == -1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    //3.打开管道
    int fd = open("fifo",O_WRONLY);
    if(fd == -1)
    {
        perror("open");
        exit(0);
    }
    //4.写数据
    for(int i =0 ;i<100; ++i)
    {
        char buf[1024];
        sprintf(buf,"hello,%d\n",i);
        printf("write data:%s \n",buf);
        write(fd,buf,sizeof(buf));
        sleep(1);
    }
    close(fd);

    return 0;
}

3.读管道：

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

//从管道中读取数据
int main()
{
    //1.打来管道文件
    int fd = open("fifo",O_RDONLY);

    if(fd == -1)
    {
        perror("open");
        exit(0);
    }
    //2.读数据
    while(1)
    {
        char buf[1024];
        int len = read(fd,buf,sizeof(buf));
        if(len ==0)
        {
            printf("写端断开连接了...\n");
            break;
        }
        printf("recv buf:%s\n",buf);
    }
    close(fd);

    return 0;

}

4.执行结果：

先结束写管道：

 先结束读管道：

4.5 有名管道与匿名管道的区别是：

有名管道是有文件实体的，匿名管道没有文件实体。 使用有名管道进行进程通信，使用创建的FIFO文件， 虽然有文件实体，操作的是内存缓冲区。  

匿名管道只能在有关的进程通信，有名管道既可以在有关系的进程间通信，也可以在没有关系的进程间通信。