Linux入门——08 进程间通讯—

1.进程间通讯

1.1什么是通讯

进程具有独立性（每个进程都有自己的PCB,独立地址空间，页表）
但是要进行进程的通信，通信的成本一定不低，打破了独立性

进程间通信目的

数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

1.2为什么要有通讯

有时候需要多进程协同，完成某种业务！ cat file | grep 'hello' //管道

1.3如何进行进程间通讯

两种通信方式

System V进程间通信------聚焦在本地通信（共享内存，信号量，消息队列）（被主流排斥了）
POSIX进程间通信-------让通讯过程可以跨主机（消息队列，共享内存，信号量，互斥量，条件变量，读写锁）
管道---------基于文件标准（匿名管道，命名管道）

1.3.1管道

管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”

该如何理解通讯的本质？

要把一个进程的数据保留到一个地方，让另一个进程去读取，这个地方必须要第三方提供，不能是进程，进程是具有独立性的。

第三方就是操作系统，直接或间接为进程通讯提供”内存空间“

要通讯的进程，必须想看到一份公共的资源（OS直接或间接提供）

不同的通讯种类

本质就是：上面所说的资源，是OS中的哪一个模块提供的！

如果i这个资源是文件体统提供的就叫这种通讯为管道

通讯的成本：

1.把必须让不同的进程看到同一份资源
2.然后通讯

任何一个文件都有自己的操作方法和属于自己的内核缓冲区（struct Page{}缓冲区）

此时我们再看父子进程，他们两个是不是共同看到了同一份资源。是由文件管理系统提供的。

父进程向文件缓冲区内写入，子进程向文件缓冲区内读取（这就是一个进程向文件中写数据，另一个进程向文件中读数据）

我们把这种通过文件的方式完成进程间的通讯的方式叫管道，操作系统提的内核级文件称为管道文件（本质就是文件）。

具有缓冲区就是为了不让文件再写入磁盘，再让另一个进程去磁盘里面读取，这样效率太慢了，需要在磁盘内存在该文件，

可以直接让OS创建struct file，只需要struct file的地址填入进程描述符表中就可以了，然后父进程创建子进程，拷贝文件描述符表，父子进程就可以直接在内存中进行通讯。

得到管道是内存级文件（不需要磁盘刷新）

如何让两个进程看到同一个管道文件呢？

fork创建子进程完成的。父子进程使用同一个文件描述符表

1.3.2匿名管道

前面我们说的管道文件，没有名称，所以称为匿名管道！

（pipe）管道函数

创建成功返回0，失败返回-1

int pipe(int pipefd[2]);

//pipefd[2] 为输出型参数
调用pipe的时候，操作系统内部，帮你打开对应的文件（读和写的方式,同一个文件打开两次，得到两个文件描述符），填充到你当前进程的文件描述符表中，
然后把文件描述符表中的对应数组下标传给pipefd[2]，这样就以读和写的方式，分别打开了同一文件



#include <iostream>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>
#include <string>
#include <cstdio>
#include <cstring>

int main()
{

    // 1.创建管道通讯
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);


    std::cout << "fds[0]:" << fds[0] << std::endl;
    std::cout << "fds[1]:" << fds[1] << std::endl;

    // 父进程读取，子进程写入
    // 2.fork()
    pid_t id = fork();
    assert(id >= 0);
    if(id == 0) //子进程
    {
        //子进程的通讯
        //子进程关闭读的描述符[0]
        close(fds[0]);
        //string msg = "hello,i am child!";
        const char *s = "我是子进程，我正在给你发消息";
        int cnt = 0;
        while(true)
        {
            char buffer[1024];//只有子进程能看到！
            snprintf(buffer,sizeof(buffer),"child->parent say:%s[%d][%d]",s,cnt,getpid());
            // snprintf(buffer,sizeof(buffer),"child->parent say:[%d][%d]",cnt,getpid());
            write(fds[1],buffer,strlen(buffer));  //不用+1，\0只是在C语言中，这是系统
            sleep(1);//细节，我每隔1s写一次
            cnt ++;
        }
        exit(0);
    }
    //父进程的通讯代码
    //父进程关闭写的描述符[1]
    close(fds[1]);
    while(true)
    {
        char buffer[1024]; //只有父进程能看到
        //ssize_t s = read(fds[0],buffer,sizeof(buffer)-1); //把读到的数据当作字符串来处理
        //这里用sizeof（buffer）
        //read 函数返回的是读取的字节数，如果读取成功，则返回值大于 0。
        //在读取前，需要清空 buffer 数组，以避免读取到之前的残留数据。
        //在判断是否有数据可读时，你使用了 strlen(buffer)-1，这可能导致读取的数据长度为负数，
        //因为 buffer 数组未初始化。应该使用 sizeof(buffer)。
        if(s > 0) buffer[s] = 0; //主动添加反斜杠0
        std::cout << "Get Message#" << buffer <<" | My Pid:"<< getpid() <<std::endl;
       
        //细节：父进程没有sleep
    }

    n = waitpid(id,nullptr,0);
    assert(n == id);
    


    return 0;
    
}
//谁读谁写
fds[0]:3   ---》下标0对应读取0对应嘴（读）
fds[1]:4   ---》下标1对应写入1对应笔（写）

管道的四种情况：

读慢写快

在进程通讯的时候，故意让子进程写的慢,sleep了一下，但当sleep的时间变长的时候，父进程读取的时间也变长，

那么在父进程读取前的时间，他在干什么?他在读取，read是一种阻塞，如果管道中没有了数据，读端在读，默认会直接阻塞当前正在读取的进程

读快写慢

相反，如果让子进程不sleep,父进程sleep(500);让子进程不断向管道中写，管道的总容量是有大小的，固定大小，

当写端向缓冲区写满的时候，写端会进入阻塞，等读端进行读取。缓冲区的数据不会被覆盖。

缓冲区的读写特点

当缓冲区有很多数据的时候，看似是一行一行写入，一行一行读取，其实是以二进制的形式指定大小进行读取

写关闭，读端读到0也会关闭。

当子进程写一条消息，直接break，这时写端的文件描述符已经关闭，只有读端还在读。总会过一段时间，将管道内的数据读完。

当读到0个字符的时候，将读的管道也关闭，读是为写作服务的，没有了写，读也没有意义。

读关闭，写就没有意义了，浪费资源，所以OS会给写进程发信号，终止写端！

1.3.3总结管道的特征

1.管道的生命周期进程就是进程的周期

2.管道可以用来进行具有血缘关系的进程之间的进程通信，常用于父子通讯。

3.管道是面向字节流的（网络部分）

4.半双工 ------ 单向通讯（特殊情况）

5.互斥与同步机制--------对共享资源进行保护的方案

1.4命名管道两个没有血缘关系进程之间的通讯。

命令行命令 mkfifo

mkfifo name_pipe

出现以p开头的文件管道，

这个文件的特点，可以一个进程进行写入，另一个进程从管道中读取

ls > named_pipe //一个终端写

cat < named_pipe //另一个终端读

这是命令行式的两进程之间的管道通讯.但是管道文件的内容大小为0

当打开同一个文件两次，操作系统不会给我们创建两个struct file对象，而是公用一个对象。
这时候向这个文件写，并不会保存到磁盘，而是在内存让另一个线程去读取，这不就是一个管道吗。

请问命名管道，让把不同的进程看到同一文件呢？

让不同的进程，打开指定名称（路径+文件名（唯一性））的同一个文件。
这就是命名管道的规则，可以通过名字来标志唯一性的。
匿名管道是通过继承，继承地址，来保证唯一性的

mkfifo（）函数创建有名管道

#include

#include

int mkfifo(constchar *filename, mode_t mode);

open(constchar *path, O_RDONLY);//1

open(constchar *path, O_RDONLY | O_NONBLOCK);//2

open(constchar *path, O_WRONLY);//3

open(constchar *path, O_WRONLY | O_NONBLOCK);//4

尽量使用阻塞方式打开

特点：

1有名管道可以使非亲缘的两个进程互相通信

2通过路径名来操作，在文件系统中可见，但内容存放在内存中

3 文件IO来操作有名管道

4 遵循先进先出规则

5 不支持leek操作

6 单工读写

注意事项：

1 程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程可以读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递

2 第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的

3 对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

4.数据完整性,如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。

1.5实现命名管道的通讯

1.5.1comm.hpp

#ifndef COMM_HPP
#define COMM_HPP
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <cassert>
#include <cerrno>
#include <unistd.h>
#include <fcntl.h>

#define NAMED_PIPE "/home/lin/Desktop/Linux_learn/named_pipe/mypipe.lin"

bool creatFifo(const std::string &path)
{
    umask(0);
    int n = mkfifo(path.c_str(),0666);
    if(n == 0) return true;
    else{
        std::cout<< "errno:"<< errno << "err string:" << strerror(errno) << std::endl;
        return false;
    }
}

void removeFifo(const std::string &path)
{
    int n = unlink(path.c_str());
    //assert不要乱用，意料之中用assert,意料之外用if判断
    assert(n == 0);  //debbug时是有效的，release的时候就没有了。
    //如果在release的时候，这个n就没有被使用，会walling ,加一个强制类型转换，会避免报错
    (void)n;  
}

#endif

1.5.2client.cc

#include "comm.hpp"

int main()
{
    std::cout << "client begin"<< std::endl;
    int wfd = open(NAMED_PIPE,O_WRONLY);
    std::cout << "client end"<< std::endl;
    if(wfd <0 )
    {
       exit(1); 
    }
    //写
    char buffer[1024];
    while (true)
    {
        std::cout << "Please Saying#";
        fgets(buffer,sizeof(buffer),stdin);
        //if(strlen(buffer)>0) buffer[strlen(buffer) - 1] = 0; 
        ssize_t n = write(wfd,buffer,strlen(buffer) );
        assert(n == strlen(buffer));
        (void)n;

    }
    

    close(wfd);

    removeFifo(NAMED_PIPE);
    return 0;
}

1.5.3server.cc

#include "comm.hpp"

int main()
{
    bool r = creatFifo(NAMED_PIPE);
    assert(r);
    (void)r;

    std::cout << "server begin"<< std::endl;
    int rfd = open(NAMED_PIPE,O_RDONLY);
    std::cout << "server end"<< std::endl;
    if(rfd <0 )
    {
       exit(1); 
    }
    //读取

    char buffer[1024];
    while(true)
    {
        ssize_t s = read(rfd,buffer,sizeof(buffer));
        if(s > 0)
        {
            buffer[s] = 0;
            std::cout << "client->server#"<< buffer;
        }
        else if(s == 0)
        {
            std::cout << "client quit,me too!" << std::endl;
        }
        else
        {
            std::cout << "err string" << strerror(errno) << std::endl; 
        }
    }

    close(rfd);

    removeFifo(NAMED_PIPE);
    return 0;
}