Linux——进程间通信一(共享内存、管道、systrem V)

一、进程间通信介绍

1.1、进程间通信的概念和意义

进程间通信(IPC interprocess communication)是一组编程接口，让不同进程之间相互传递、交换信息(让不同的进程看到同一份资源)

数据传输:一个进程需要将它的数据发送给另外一个进程

资源共享:多个进程之间共享同样的资源

通知事件:一个进程向另一个或一组发送消息

进程控制:有些进程希望完全控制另一个进程的执行

为什么要进行进程间通信？

以上的行为往往需要多个进程协同、共同完成一些事情

两个进程之间是不能进行"数据"的直接传递的(进程具有独立性)

不要以为，进程独立了就是彻底独立，有时我们需要双方能够进行一定程序的信息交互。

1.2、如何进行进程间通讯及其本质

怎么办？

一般规律

1、交换数据的空间(内存)

2、不能由通信双方任何一个提供(那由谁提供，OS提供)

具体做法

OS提供的"空间"有不同的样式，就决定了有不同的通信方式

1、管道(匿名、命名)

2、共享内存

3、消息队列

4、信号量

进程间通信的本质：让不同的进程看到同一份资源(一般由OS提供)

为了进程在通信的时候，既能满足进程之间的独立性，又能够到达通信的目的，那么进程之间通信的地点就不能在两个进程中。 一个进程将自己的数据交给另一个进程，并且还要等待另一个进程的应答，这样一来，这个进程将不独立了，受到了另一个进程的影响，这就与进程的独立性矛盾。所以，两个进程进行通信的地点必须是由第三方提供的，第三方只能是操作系统。操作系统提供的这个地点被我们称为：公共资源。公共资源有了，还必须让要通信的进程都看到这一份公共资源，此时要通信的进程将有了通信的前提。之后就是进程通信，也就是访问这块公共资源的数据。

之所以有不同的通信方式，是因为公共资源的种类不一，如果公共资源是一块内存，那么通信方式就叫做共享内存，如果公共资源是一个文件，也就是struct file结构体，那么就叫做管道。

二、管道

2.1管道介绍

什么是管道？

open("log.txt",w);
open("log.txt",r);

一个文件打开两次，那么在操作系统中会有2个struct file 但是这两个struct file指向同一个缓冲区

若父进程3为读端，4为写端，子进程也一样。那么子进程写入，父进程读取缓冲区内容，这是父子进程看到了同一块资源。

这种基于文件的，让不同进程看到同一份资源的通信方式叫做管道

管道只能被设计成单向通信

如：子进程为写(writer，关掉读端) 父进程为读(reader，关掉写端) 当子进程关掉读端/父进程关掉写端对应的struct file没有释放掉，说明 struct file有引用计数(记录多少指针指向我) 当引用计数为0才释放。struct file是允许多个进程通过指针指向的。

为什么父进程最开始用rw方式打开同一个文件呢？ 如果只以r方式打开的话，子进程拷贝完后就也是r；父进程只以w打开，子进程拷贝完也只是w

3.2匿名管道

匿名管道：就是没有名字的文件

如何让不同的进程看到同一份资源？匿名管道的解决办法是：创建子进程，继承父进程的属性信息，也就是说匿名管道可以(只能)进行具有血缘关系的进程进行进程间通信(常用于父子)

为了支持我们进行管道通信，OS提供系统调用pipe()

原型：int pipe(int fd[2]);

头文件unistd.h

功能:创建一无名管道

参数 fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端

返回值:成功返回0，失败返回错误代码

3.3匿名管道代码

通过系统调用接口创建一个匿名管道

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>
 
using namespace std;
 
int main()
{
    int pipefd[2];
    int ret = pipe(pipefd); // 一.创建管道
    if(ret < 0)
    {
        cerr << errno << ": " << strerror(errno) << endl;
    }
    cout << "pipefd[0]: " << pipefd[0] << endl; // 3
    cout << "pipefd[1]: " << pipefd[1] << endl; // 4
 
    return 0;
}

然后就可以创建子进程，关闭不需要的读端或写端

#include <iostream>
#include <cerrno>
#include <cstring>
#include <unistd.h>
 
using namespace std;

int main()
{
    int pipefd[2];
    int ret = pipe(pipefd); // 一.创建管道
    if(ret < 0)
    {
        cerr << errno << ": " << strerror(errno) << endl;
    }
    pid_t id = fork(); // 二.创建子进程
    assert(id != -1);
    if(id == 0)
    {
        //子进程  关掉读端，只写
        close(pipefd[0]);
        
        exit(1);
    }

    //父进程
    //关掉写端，只读
    close(pipefd[1]);
    
    close(pipefd[0]); // 父进程，只写，关闭读
 
    return 0;
}

这时父子进程已经可以看到同一份资源，可以开始通信了

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

void writer(int wfd)
{
    const char* str = "我是子进程,o.O,我在给你发消息";
    char buffer[128];
    int cnt = 0;
    pid_t pid = getpid();
    while(1)
    {
        snprintf(buffer,sizeof(buffer),"message:%s,pid:%d,count:%d\n",str,pid,cnt);
        write(wfd, buffer, strlen(buffer));
        cnt++;
        sleep(1);
    }
    close(wfd);
}

void reader(int rfd)
{
    char buffer[1024];
    int cnt = 10;
    while(1)
    {
        size_t n = read(rfd,buffer,sizeof(buffer)-1);
        if(n>0)
            printf("父亲获得信息是: %s\n", buffer);
        else
        {
            printf("缓冲区读完了，文件也读完了\n");
            break;
        }
        cnt--;
        if(cnt==0)
            break;
    }
    close(rfd);
}


int main()
{
    //创建管道
    int pipefd[2];
    int n = pipe(pipefd);
    if(n<0)
        return 1;
    pid_t id = fork();

    if(id == 0)
    {
        //子进程  关掉读端，只写
        close(pipefd[0]);
        writer(pipefd[1]);
        exit(1);
    }

    //父进程
    //关掉写端，只读
    close(pipefd[1]);
    reader(pipefd[0]);
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid == id)
        printf("退出码为:%d,信号为:%d\n",WEXITSTATUS(status), status & 0x7f);

    return 0;
}

匿名管道的一些读写现象以及对应的特性

按上面代码将子进程休眠上5s，那么在子进程休眠这段时间，父进程在等待子进程退出休眠(可以理解为管道内无数据)

写端一直写，读端一直不读或者很久读一次：若一次写入一个字符"A"，每次写入时cnt++，执行后会发现当cnt=65536时不在写入(也就是写入65536个字节时)65536÷1024=64

在Ubuntu20.04操作系统下默认建立的管道大小为64KB；

管道内部被写满，父进程还没有读取的时候，那子进程要等到父进程来读它

对以上两种情况的总结：

1.管道内部没有数据且子进程不关闭自己的写端文件fd，读端就要阻塞等待直到pipe有数据

2.管道内部被写满且读端不关闭自己的fd，写端写满后就要阻塞等待

由此推断出管道的两种特性：

特性一：自带同步机制

特性二：血缘关系进程进行通信，常见父子

若把父进程休眠时间改短一点，每次父进程读完后，子进程又能继续写入，在此过程中我们不难发现：无论写端写多少个，读端都能一次读完，由此我们发现管道的另一个特性：

特性三：管道是面向字节流的(写多少次和读多少次没有直接关系，称为面向字节流)

当子进程写入10s后退出，而父进程一直读，且打印了返回值，10s后子进程关掉写文件描述符，此时返回值为0；若父进程退出，子进程会僵尸

3.对于写端而言，不写且关闭pipe，读端会将管道中的数据读完，返回值为0，表示读结束，类是读到了文件的结尾

若写端一直在写，而读端读一会就结束，关闭读文件描述符

4.读端不读且关闭，写端在写，OS会直接终止写入的进程(通过信号13SIGPIPE杀死进程)

由此可以得出管道另外的特性

特性四：父子进程退出，管道自动释放，文件的生命周期是随进程的

特性五：管道只能单向通信，半双工的一种特殊情况(一方传信息时，另一方不能传，如：对讲机)
5.当要写入的数据量不大于PIPE_BUF(4KB)时，linux将保证写入的原子性。

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

就是写入数据小于4kb，则次操作为安全的

有时候公共资源有可能被两个执行流共同访问，访问时会出现信息交叉、数据混乱等问题；由此我们要有一种特性：一段数据、一块空间或一种资源我们要么不访问、要访问就把它改完了，这种特性叫原子性。

3.3进程池

processpool.cc

#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>
#include <unistd.h>
#include <ctime>
#include "task.hpp"

using namespace std;


enum
{
    UsageError= 1,
    ArgError,
    PipeError
};
void Usage(const std::string &proc)
{
    cout<<"Usage:"<<proc<<"sub_process_num"<<endl;
}
//用一个类封装管道
class Channel
{
public:
    Channel(int wfd,pid_t sub_id,const std::string &name)//构造
        :_wfd(wfd)
        ,_sub_process_id(sub_id)
        ,_name(name)
        {}
    void PrintDebug()
    {
        cout << "_wfd: " << _wfd;
        cout << ",_sub_process_id: " << _sub_process_id;
        cout << ", _name: " << _name << endl;
    }
    string name() {return _name;}
    int wfd() {return _wfd;}
    pid_t pid() { return _sub_process_id; }
    ~Channel()//析构
    {
    }

private:
    int _wfd;//父进程通过此向channel写东西
    pid_t _sub_process_id;//记录子进程
    string _name;//channel名字
};

//将冗长的创建子进程封装一下
class ProcessPool
{
public:
    ProcessPool(int sub_process_num) //构造
        : _sub_process_num(sub_process_num)
    {}
    int CreateProcess(work_t work) // 回调函数
    {
        for (int number = 0; number < _sub_process_num; number++)
        {
            int pipefd[2]{0};
            int n = pipe(pipefd);
            if (n < 0)
                return PipeError;

            pid_t id = fork();
            if (id == 0)
            {
                // child -> r
                close(pipefd[1]);
                // 执行任务
                dup2(pipefd[0], 0);
                work();
                exit(0);
            }
            string cname = "channel-" + to_string(number);
            // father
            close(pipefd[0]);
            channels.push_back(Channel(pipefd[1], id, cname));
        }
        return 0;
    }
    int NextChannel()
    {
        static int next = 0;
        int c = next;
        next++;
        next %= channels.size();
        return c;
    }
    void SendTaskCode(int index, uint32_t code)
    {
        cout << "send code: " << code << " to " << channels[index].name() << " sub prorcess id: " <<  channels[index].pid() << endl;
        write(channels[index].wfd(), &code, sizeof(code));
    }
    void Debug()
    {
        for (auto &channel : channels)
        {
            channel.PrintDebug();
        }
    }
    ~ProcessPool()
    {
    }

private:
    int _sub_process_num;
    vector<Channel> channels;
};


int main(int argc ,char* argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        return UsageError;
    }

    int sub_process_num = std::stoi(argv[1]);//把进程数转整型
    if(sub_process_num == 0)
        return ArgError;

    //vector<Channel> channels;
    //把所有的channel(管道)push到vector中，那么对管道的管理就会变成对vector的增删查改
    //create process
    // for(int num=0;num<sub_process_num;num++)
    // {
    //     int pipefd[2]{0};
    //     int n = pipe(pipefd);
    //     if(n<0)
    //         return PipeError;
    //     pid_t id = fork();
    //     if(id == 0)//子进程
    //     {
    //         close(pipefd[1]);
    //         sleep(1);
    //         exit(0);
    //     }
    //     string cname = "channel-"+to_string(num);
    //     //父进程
    //     close(pipefd[0]);
    //     channels.push_back(Channel(pipefd[1],id,cname));
    // }
    ProcessPool *proc_ptr = new ProcessPool(sub_process_num);
    proc_ptr->CreateProcess(worker);
    //控制子进程
    // for(auto& e:channels)
    // {
    //     e.PrintDebug();
    // }
    while(1)
    {
        // a. 选择一个进程和通道
        int channel = proc_ptr->NextChannel();
        // cout << channel.name() << endl;

        // b. 你要选择一个任务
        uint32_t code = NextTask();

        // c. 发送任务
        proc_ptr->SendTaskCode(channel, code);

        sleep(1);
    }

    //回收、等待子进程
    delete proc_ptr;
    return 0;
}

task.hpp

#include <iostream>
#include <unistd.h>

using namespace std;

typedef void(*work_t)();  //函数指针类型
typedef void(*task_t)();  //函数指针类型

void PrintLog()
{
    cout << "printf log task" << endl;
}

void ReloadConf()
{
    cout << "reload conf task" << endl;
}

void ConnectMysql()
{
    cout << "connect mysql task" << endl;
}

task_t tasks[3] = {PrintLog, ReloadConf, ConnectMysql};

uint32_t NextTask()
{
    return rand() % 3;
}

void worker()
{
    // 从0中读取任务即可！
    while(true)
    {
        uint32_t command_code = 0;
        ssize_t n = read(0, &command_code, sizeof(command_code));
        if(n == sizeof(command_code))
        {
            if(command_code >= 3) continue;
            tasks[command_code]();
        }
        cout << "I am worker: " << getpid() << endl;
        sleep(1);
    }
}

makefile

processpool:processpool.cc
	g++ -o $@ $^ -std=c++11 -g
.PHONY:clean
clean:
	rm -f processpool

三、命名管道

管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。
如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。
命名管道是一种特殊类型的文件

man mkfifo：

指令：mkfifo 文件名

功能：创建命名管道文件

命名管道可以从命令行上创建，命令行方法是使用下面这个命令

mkfifo filename

此时就成功地建立了一个命名管道，可以发现它的（文件类型）权限前面的字母是p（pipe），而目录的文件类型是d（directory）。命名管道文件类型是p，而且该文件还有inode，说明在磁盘上是真实存在的。

当磁盘中有了命名管道文件以后，两个进程将可以通过这个管道文件进行通信了，步骤和匿名管道非常相似。一个进程以写方式打开管道文件，另一个进程以读端方式打开管道文件。

直接写入的话可以发现会阻塞在这里

它需要被另一个进程读取

可以通过unlink或者rm删掉命名管道

系统调用mkfifo以及unlink

第一个形参：管道文件的名字

第二个形参：创建管道文件的权限

返回值：0表示创建成功，-1表示创建失败。

man 2 unlink