【Linux】解锁管道通信和共享内存通信，探索进程间通信的海洋

引言：

1、进程间通信基础介绍

1.1为什么需要在进程之间通信？

1.2进程间通信是什么？

1.3我们具体如何进行进程间的通信呢？

a.一般规律：

b.具体做法

2.管道

2.1什么是管道

2.2匿名管道：

创建方法：pipe函数创建

2.3匿名管道的bug:

3.匿名管道的读写规则

4种情况

5种特性：

在父端写，子端读的情况下子进程的读端为什么都是3？

4.命名管道

4.1.管道的本质

4.2创建一个命名管道

4.3.匿名管道与命名管道的区别

4.4用命名管道实现server&client通信

5.共享内存方式通信：

5.1共享内存如何实现让不同的进程看到同一份资源呢？

5.2.关于共享内存的函数

shmget函数

问题1：这个key是怎么形成的？意义是什么？

问题2：在调用shmget函数时，为什么要让用户传入key值呢？

shmctl函数删除共享内存

shmat函数挂接共享内存

shmdt函数去关联

5.3共享内存的大小

5.4共享内存的原理

5.5.key和shmid到底有什么区别

5.6.共享内存的优缺点

优点：共享内存是所有进程间通信中速度最快的

缺点：

6、信号量

6.1.关于信号量的理论知识

6.2.信号量的原理

在多进程场景下，int全局变量是不能实现计数器的效果呢？

引言：

两个进程之间，可以进行“数据”的直接传送吗？不能！因为进程具有独立性！

进程为什么会有独立性，本质原因是：这两个进程都有自己的虚拟地址空间，但是他们的正文代码，堆，栈，共享区等被映射到了内存当中的不同的物理空间，所以在内存方面具有独立性，不会互相影响

1、进程间通信基础介绍

1.1为什么需要在进程之间通信？

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

总结一句话就是，在OS中，往往需要多个进程协同，共同完成一些事情。

1.2进程间通信是什么？

一个进程把自己的数据，能够交给另一个进程。

1.3我们具体如何进行进程间的通信呢？

a.一般规律：

进程间通信的本质：先让不同的进程，看到同一份资源（一般都是要有OS提供）

b.具体做法

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

管道（匿名管道和命名管道）
共享内存
消息队列
信号量

2.管道

2.1什么是管道

这里的子进程并没有将父进程的struct file拷贝下来，由此可见子进程继承父进程的方式是浅拷贝，所以父进程和子进程指向的都是同一份资源！但是子进程会继承父进程的读写段。

因此基于文件的，让不同的进程看到同一份资源的通信方式，叫做管道！管道只能被设计成为单向通信。

为什么父进程最开始，就要将读写两端都开启的形式去打开同一个文件呢？

因为子进程会继承父进程的读写端，而管道的要求就是单向通信，因此父进程就需要将读写段同时打开，等子进程继承之后，会根据要求，各自关掉不用的描述符

2.2匿名管道：

匿名管道：可以（只能）进行具有血缘关系的进程之间进行进程间通信！（常用于父子）

那么匿名管道如何做到让不同的进程看到同一份资源呢？创建子进程，子进程会继承父进程的相关属性信息！

创建方法：pipe函数创建

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);

参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端，这是输出型参数，需要由这两个参数找到匿名管道（匿名文件）

默认fd[0]表示读端，fd[1]表示写端
返回值:成功返回0，失败返回错误代码

下面实现一个父进程读数据，然后通过管道让子进程读。

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

void writer(int wfd)
{
    const char *str = "hello father, I am child";
    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);
    }
}
void reader(int rfd)
{
    char buffer[1024];
    while(1)
    {
        ssize_t n = read(rfd, buffer, sizeof(buffer)-1);
        (void)n;
        printf("father get a message: %s", buffer);
    }
}


int main()
{
    // 1. 
    int pipefd[2];
    int n = pipe(pipefd);
    if(n < 0) return 1;
    printf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0]/*read*/, pipefd[1]/*write*/); // 3, 4

    // 2. 
    pid_t id = fork();
    if(id == 0)
    {
        //child: w
        close(pipefd[0]);

        writer(pipefd[1]);

        exit(0);
    }

    // father: r
    close(pipefd[1]);

    reader(pipefd[0]);
    wait(NULL);

    return 0;
}

2.3匿名管道的bug:

子进程继承父进程后，拷贝过父进程的文件描述表，后续子进程在创建的时候，会复制原先父进程的写端，就会导致管道有不止一个写端的BUG

比如这里的4就是子进程的4也是写端

我们的目的是让父进程和子进程之间只有一个写端一个读端，那如何修正这个问题呢？这就需要我们在子进程拷贝父进程的文件描述表的时候，将文件表的读写端口刷新！

3.匿名管道的读写规则

4种情况

管道内部没有数据&&子进程不关闭自己的写端文件fd，读端（富）就要阻塞等待，知道pipe有数据
管道内部被写满&&父进程（读端不关闭自己的fd，写端（子））写满之后，就要阻塞等待
对于写端而言：不写了&&关闭了pipe，读端会将pipe中的数据读完，最后就会读到返回值为0，表示读结束，类似读到了文件的结尾
读端不读&&关闭，写端在写，OS会直接终止写入的进程（子进程），通过信号13信号杀掉进程

5种特性：

自带同步机制
血缘关系进程进行通信，常见于父子
pipe是面向字节流的
父子退出，管道自动释放，文件的声明中周期是随进程的
管道只能单向通信，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道

曾经我们学习的命令行管道（匿名），本质就是我们今天学习的pipe。

在父端写，子端读的情况下子进程的读端为什么都是3？

解释：刚开始父进程3是读端，4是写端，子进程会继承父进程的读写端口。下面是父端写，子端读的情况，那么就需要将父端的读关掉，就是将3关掉，然后将子进程的写端关掉，也就是将子进程的4关掉。父进程会循环创建管道，创建子进程。

所以父进程就会分配两个端口给这个管道进行读写，此时的3就被分配给了读端，5分配给了写端

子进程会拷贝父进程的文件描述表，所以3也是子进程的读端，5就是写端。这样父亲又开始写了，所以父进程的读端3就会被丢掉，子进程要写，那么就把5丢掉了。那么以此类推，所以子进程的读端一直都是3

4.命名管道

4.1.管道的本质

让不同的进程之间可以通信，让不同的进程看到同一份资源（文件）！

那么你怎么保证两个不同的进程打开的是同一个文件？如何让不同的进程看到同一份资源呢？

找到文件：文件的路径 + 文件名

匿名管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。

如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。

注意命名管道是一种特殊类型的文件！

4.2创建一个命名管道

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

$ mkfifo filename

命名管道也可以从程序里创建，相关函数有

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

头文件：

返回值

程序里面创建命名管道

int main(int argc, char *argv[])
{
mkfifo("p2", 0644);
return 0;
}

生成多个可执行程序的方法

4.3.匿名管道与命名管道的区别

匿名管道由pipe函数创建并打开。
命名管道由mkfifo函数创建，打开用open
FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。
命名管道和匿名管道之间的主要差异就是，命名管道可以让两个没有任何关系的进程进行通信

4.4用命名管道实现server&client通信

PipeClient.cc

#include "Comm.hpp"

int main()
{
    int wfd = open(Path, O_WRONLY);
    if (wfd < 0)
    {
        cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        return 1;
    }

    string inbuffer;
    while (true)
    {
        cout << "Please Enter Your Message# ";
        std::getline(cin, inbuffer);
        if(inbuffer == "quit") break;
        ssize_t n = write(wfd, inbuffer.c_str(), inbuffer.size());
        if (n < 0)
        {
            cerr << "write failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
            break;
        }
    }

    close(wfd);
    return 0;
}

Comm.hpp

#ifndef __COMM_HPP__
#define __COMM_HPP__

#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

using namespace std;

#define Mode 0666
#define Path "./fifo"

class Fifo
{
public:
    Fifo(const string &path) : _path(path)
    {
        umask(0);
        int n = mkfifo(_path.c_str(), Mode);
        if (n == 0)
        {
            cout << "mkfifo success" << endl;
        }
        else
        {
            cerr << "mkfifo failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        }
    }
    ~Fifo()
    {
        int n = unlink(_path.c_str());
        if (n == 0)
        {
            cout << "remove fifo file " << _path << " success" << endl;
        }
        else
        {
            cerr << "remove failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        }
    }

private:
    string _path; // 文件路径+文件名
};

#endif

PipeServer.cc

#include "Comm.hpp"
#include <unistd.h>

// 基于命名管道，创建一个进程池呢？？？
int main()
{
    Fifo fifo(Path);

    int rfd = open(Path, O_RDONLY);
    if (rfd < 0)
    {
        cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        return 1;
    }
    // 如果我们的写端没打开，先读打开，open的时候就会阻塞，直到把写端打开，读open才会返回
    cout << "open success" << endl;

    char buffer[1024];
    while (true)
    {
        ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            buffer[n] = 0;
            cout << "client say : " << buffer << endl;
        }
        else if (n == 0)
        {
            cout << "client quit, me too!!" << endl;
            break;
        }
        else
        {
            cerr << "read failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
            break;
        }
    }

    close(rfd);
    return 0;
}

5.共享内存方式通信：

上面我们讲述的是关于管道通信方式，下面我们来讲解共享内存的通信方式。

5.1共享内存如何实现让不同的进程看到同一份资源呢？

我们首先在内存中开辟一段空间，是由操作系统开辟的
接着让这份共享内存对不同的进程构建映射
移除映射
删除共享内存

共享内存在内核中同时可以存在很多个，OS必须要管理所有的共享内存。如何管理呢？先描述，再组织。系统中会存在很多共享内存！

那么我们怎么保证，两个或者多个不同的进程看到的是同一个共享内存呢？
所以我们要给共享内存提供唯一性的标识！

5.2.关于共享内存的函数

shmget函数

功能：用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);

参数
key:共享内存在内核中的唯一性标识
size:共享内存大小
shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1

shmflg标志讲解：

问题1：这个key是怎么形成的？意义是什么？

使用函数ftok来生成key，并且这个函数的参数可以随便传；key的值是多少并不重要，只要能够标识唯一性即可。

问题2：在调用shmget函数时，为什么要让用户传入key值呢？

因为当我们一个进程使用ftok函数有了唯一性的标识后，我们两个不同的进程只需要输入相同的key值就可以看见共享内存了！这个key值相当于一个桥梁，沟通了两个不同的进程去看见了同一份共享内存！！！让OS传，OS做不到！

shmctl函数删除共享内存

功能：用于控制共享内存
原型
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数
shmid:由shmget返回的共享内存标识码
cmd:将要采取的动作（有三个可取值）
buf:指向一个保存着共享内存的模式状态和访问权限的数据结构
返回值：成功返回0；失败返回-1

shmat函数挂接共享内存

功能：将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数
shmid: 共享内存标识
shmaddr:指定连接的地址，用户指明将shm挂接到哪里
shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1