【Linux】进程间通信——管道

忘是亡心i 2024-04-27 07:34 64阅读 0赞

#### 文章目录 ####

*  一、进程间通信
 *   *  进程间通信的目的
     *  进程间通信的发展和分类
 *  二、匿名管道
 *   *  管道介绍
     *  管道的原理
     *  管道的实现
     *  管道的特点
     *  管道的四种场景
     *  mini进程池的实现
 *  三、命名管道
 *   *  命名管道模拟客户端和服务端

--------------------

## 一、进程间通信 ##

`进程间通信（Interprocess Communication）` 就是两个进程之间进行通信。进程是具有独立性（虚拟地址空间 + 页表保证进程运行的独立性），所以进程间通信成本会比较高！进程间通信的前提条件是先让不同的进程看到同一份资源（内存空间），该资源不能隶属于任何一个进程，应该属于操作系统，被进行通信的进程所共享。

### 进程间通信的目的 ###

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

### 进程间通信的发展和分类 ###

进程间通信的发展和分类如下：

*  Linux 原生能提供的管道，管道主要包括匿名管道 pipe 和命名管道。
 *  SystemV 进程间通信，System V IPC 主要包括 System V 消息队列、System V 共享内存和 System V 信号量。System V 只能本地通信。
 *  POSIX 进程间通信，POSIX IPC 主要包括消息队列、共享内存、信号量、互斥量、条件变量和读写锁。POSIX 进程通信既能进行本地通信，又能进行网络远程通信，具有高扩展和高可用性。

--------------------

## 二、匿名管道 ##

### 管道介绍 ###

日常生活中，有非常多的管道，如：天然气管道、石油管道和自来水管道等。**`管道是 Unix 中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的一个数据流称为管道。管道传输的都是资源，并且只能单向通信。`**

![在这里插入图片描述][e7eaf4a45a224798a877793ff54ea497.png]

### 管道的原理 ###

每个进程都有对应的文件描述符表，文件描述符表中有相应的数组，数组中存放了标准输入0，标准输出1，标准错误2，而每个进程描述符都会存放相应struct file的地址，在进程间通信的时候系统会提供一个内存文件，这个内存文件不会在磁盘刷新，这个文件被称为匿名文件，当我们以读和写方式打开一个文件，然后我们fork创建一个子进程，子进程也具有task\_struct，并且子进程会继承父进程的文件描述符表（但是不会复制父进程打开的文件对象），而文件描述符表中存放文件的地址都是相同的，所以子进程的文件描述符表也指向父进程的文件，正是因为这样，在父进程以读和写打开一份文件，而子进程也同样读和写打开和父进程打开的一样的一份文件，这就让两个进程看到了同一份资源。但是这种管道只能实现单向通信，比如我们关闭父进程的写端，关闭子进程的读端让子进程去写这两个进程就实现单向通信了。管道只能单向通信的原因是文件只有一个缓冲区，一个写入位置一个读取位置所以只能单向通信，要是想双向通信那就打开两个管道！而上面所讲的管道就是**匿名管道**。

![在这里插入图片描述][3ed5f9e701ce43579ecb4f036b96e64c.png]

--------------------

### 管道的实现 ###

? **Makefile**

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

? **代码实现**

#include <iostream>
    #include <cassert>
    #include <string>
    #include <unistd.h>
    #include <cstring>
    #include <sys/types.h>
    #include <sys/wait.h>
    
    using namespace std;
    
    int main()
    {
        
        // 让不同的进程看到同一份资源
        int pipefd[2] = {
        0};
        
        // 1.创建管道
        int n = pipe(pipefd);
    
        if(n < 0)
        {
        
            std::cout << "pipe error, " << errno << ": " << strerror(errno) << std::endl;
            return 1;
        }
    
        // printf("pipefd[0]:%d\n",pipefd[0]);
        // printf("pipefd[1]:%d\n",pipefd[1]);
    
        // 创建子进程
        pid_t id = fork();
        assert(id != -1);
        
        if(id == 0) //子进程 —— 往管道中写入数据
        {
        
            close(pipefd[0]);
    
            //开始通信
            const string namestr = "hello,我是子进程";
            int cnt = 1;
            char buffer[1024];
    
            while(true)
            {
        
                snprintf(buffer, sizeof buffer, "%s, 计数器: %d, 我的PID: %d", namestr.c_str(), cnt++, getpid());
                write(pipefd[1], buffer, strlen(buffer));
                sleep(1);
            }
            close(pipefd[1]);
            exit(0); 
        }
    
        //父进程 —— 从管道中读取数据
        close(pipefd[1]);
        char buffer[1024];
        //int cnt = 0;
        while(true)
        {
        
            int n = read(pipefd[0], buffer, sizeof(buffer) - 1);
            if(n > 0)
            {
        
                buffer[n] = '\0';
                cout << "我是父进程,子进程给我的message是:" << buffer << endl;
            }
            else if(n == 0)
            {
        
                cout << "我是父进程,读到了文件的结尾" << endl;
                break;
            }
            else
            {
        
                cout << "我是父进程,读取异常了" << endl;
                break;
            }
        }
        close(pipefd[0]);
    
        return 0;
    }

**运行结果如图：**  
![在这里插入图片描述][61f97097932343d09caaa2337eccd12b.png]  
![在这里插入图片描述][7898a2fe0f9545748b284e049832b1d4.png]

这里确实完成了进程间的单向通信，我们可以清晰地看到有两个进程，并且子进程将自己的数据给了父进程。

--------------------

### 管道的特点 ###

>  *  单向通信
>  *  管道的本质是文件，因为fd的生命周期随进程，管道的生命周期也是随进程的。
>  *  管道通信，通常是用来进行 **“血缘关系”** 的进程，进行进程间通信，常用于父子进程间通信——pipe打开管道，并不清楚管道的名字，所以是匿名管道。
>  *  在管道通信中，写入的次数，和读取的次数，不是严格匹配的 读写次数的多少没有强相关 — 表现 ----字节流。
>  *  具有一定的协同能力，让reader和writer能够按照一定的步骤进行通信 — 自带同步机制。
>  *  管道是基于文件的，文件的生命周期是随进程的，那么管道的生命周期也是随进程的。
>  *  一般而言，内核会对管道操作进行同步与互斥
>  *  管道是单向通信的，就是半双工通信的一种特殊情况，数据只能向一个方向流动。需要双方通信时，需要建立起两个管道。半双工通信就是要么在收数据，要么在发数据，不能同时在收数据和发数据（比如两个人在交流时，一个人在说，另一个人在听）；而全双工通信是同时进行收数据和发数据（比如两个人吵架的时候，相互问候对方，一个人既在问候对方又在听对方的问候）。
>  *  当要写入的数据量不大于 PIPE\_BUF 时，Linux 将保证写入的原子性。
>  *  当要写入的数据量大于 PIPE\_BUF 时，Linux 将不再保证写入的原子性。
>  *  指事务的不可分割性，一个事务的所有操作要么不间断地全部被执行，要么一个也没有执行。

--------------------

### 管道的四种场景 ###

*  如果我们read读取完毕了所有的管道数据，如果对方不发，我就只能等待

这里我们让父进程的读取速度不变，让子进程写的慢一些。

![在这里插入图片描述][f3793f1c119e4228b8592b79e1822463.png]  
![在这里插入图片描述][9225f6e29ff34cd5a00c0c438bee0efa.png]

这里我们可以看到，光标卡在这儿不动了，这是因为子进程每隔5秒向管道写入一次数据，因此，如果管道中没有数据，读端在读，此时默认会直接阻塞当前正在读取的进程

*  如果我们writer端将管道写满了，我们将不能继续往管道中写入数据。

![在这里插入图片描述][dd86c8262e404cd892d3ae9e2d26743a.png]  
![在这里插入图片描述][c9736645b6074041bf1919235cd4dfdf.png]

管道是固定大小的缓冲区，当管道被写满，就不能再写了。此时写端会阻塞。因此管道**具有一定的协同能力，能让reader和writer按照一定的步骤进行通信**。

*  如果关闭了写端，读取完毕管道数据，在读，就会read返回0，表明读到了文件结尾。

![在这里插入图片描述][1ab229b0dc4343b78650dcab5c7f9d8c.png]

![在这里插入图片描述][5dc7069724a3452687a936323b54e9ec.png]

*  写端一直写，读端关闭，操作系统不会维护无意义，低效率，或者浪费资源的事情。因此OS会杀死一直在写入的进程!

![在这里插入图片描述][2c96c6e7fa1d438e961c22ca5b486aef.png]  
![在这里插入图片描述][a4c1f0a9816a476589d873546ccebf9c.png]

这里我们看到确实如此，OS不会维护无意义，低效率，或者浪费资源的事情，因此操作系统通过`13号信号`来杀死了子进程。

--------------------

### mini进程池的实现 ###

// Task.hpp的实现
    #pragma once 
    
    #include <iostream>
    #include <vector>
    #include <unistd.h>
    using namespace std;
    
    //定义函数指针
    typedef void (*func_t) ();
    
    void PrintLog()
    {
        
        std::cout << "pid: "<< getpid() << ", 打印日志任务，正在被执行..." << std::endl;
    }
    
    void InsertMySQL()
    {
        
        std::cout << "执行数据库任务，正在被执行..." << std::endl;
    }
    
    void NetRequest()
    {
        
        std::cout << "执行网络请求任务，正在被执行..." << std::endl;
    }
    
    //这里我们规定,每一个command都必须是四字节
    #define COMMAND_LOG 0
    #define COMMAND_MYSQL 1
    #define COMMAND_REQEUST 2
    
    class Task
    {
        
    public:
        Task()
        {
        
            funcs.push_back(PrintLog);
            funcs.push_back(InsertMySQL);
            funcs.push_back(NetRequest);
        }
    
        void Execute(int command)
        {
        
            if(command >=0 && command < funcs.size())
                funcs[command]();
        }
    
        ~Task()
        {
        };
    public:
        vector<func_t> funcs;
    };
    
    // ctrlProcess的实现
    #include <iostream>
    #include <vector>
    #include <cassert>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    using namespace std;
    #include "Task.hpp"
    
    const int gnum = 3;
    Task t;
    
    class Endpoint
    {
        
    private:
        static int number;
    public:
        Endpoint(pid_t id, int write_fd)
            :_child_id(id)
            ,_write_fd(write_fd)
        {
        
            char namebuffer[64];
            snprintf(namebuffer, sizeof namebuffer, "process-%d[%d:%d]", number++, _child_id, _write_fd);
            processname = namebuffer;
        }
    
        string name() const
        {
        
            return processname;
        }
    
        ~Endpoint()
        {
        };
    public:
        pid_t _child_id;
        int _write_fd;
        string processname;
    };
    
    int Endpoint::number = 0;
    
    //子进程要执行的方法
    void WaitCommand()
    {
        
        while(true)
        {
        
            int command = 0;
            int n = read(0, &command, sizeof(int));
            if(n == sizeof(int))
            {
        
                t.Execute(command);
            }
            else if(n == 0)
            {
        
                cout << "父进程让我退出，我就退出了: " << getpid() << endl; 
                break;
            }
            else
            {
        
                break;
            }
        }
    }
    
    void createProcesses(vector<Endpoint>* end_points)
    {
        
        vector<int> fds;
        for(int i = 0; i < gnum; i++)
        {
        
            // 1.1 创建管道
            int pipefd[2] = {
        0};
            int n = pipe(pipefd);
            assert(n == 0);
            (void)n;
    
            // 1.2 创建进程
            pid_t id = fork();
            assert(id != -1);
    
            //子进程 —— 从管道中读取数据
            if(id == 0)
            {
        
                for(auto& fd : fds) close(fd);
    
                close(pipefd[1]);
                dup2(pipefd[0], 0); // 子进程读取指令的时候,从标准输入读取 == 输入重定向
                
                WaitCommand(); // 子进程等待获取命令
                close(pipefd[0]);
                exit(0);
            }
            //1.3 父进程——关闭不需要的fd
            close(pipefd[0]);
    
            // 1.4 将新的子进程和他的管道写端构建对象
            end_points->push_back(Endpoint(id, pipefd[1]));
    
            fds.push_back(pipefd[1]);
        }
    }
    
    int ShowBoard()
    {
        
        std::cout << "------------------------------------------" << std::endl;
        std::cout << "|   0. 执行日志任务   1. 执行数据库任务    |" << std::endl;
        std::cout << "|   2. 执行请求任务   3. 退出             |" << std::endl;
        std::cout << "------------------------------------------" << std::endl;
        std::cout << "请选择$ ";
        int command = 0;
        std::cin >> command;
        return command;
    }
    
    void ctrlProcess(const vector<Endpoint>& end_points)
    {
        
        int num = 0;
        int cnt = 0;
        while(true)
        {
        
            // 1. 选择任务
            int command = ShowBoard();
            if(command == 3) break;
            if(command < 0 || command > 3) continue;
    
            // 2.选择进程
            int index = cnt++;
            cnt %= end_points.size();
    
            cout << "选择了进程: " <<  end_points[index].name() << " | 处理任务: " << command << endl;
    
            // 3. 下发任务
            write(end_points[index]._write_fd, &command, sizeof(command));
            sleep(1);
        }
    }
    
    void waitProcess(const vector<Endpoint>& end_points)
    {
        
        for(int end = 0; end < end_points.size(); end++)
        {
        
            cout << "父进程让子进程退出:" << end_points[end]._child_id << endl;
            close(end_points[end]._write_fd);
    
            waitpid(end_points[end]._child_id, nullptr, 0);
            cout << "父进程回收了子进程:" << end_points[end]._child_id << endl;
        }
        sleep(5);
    }
    
    int main()
    {
        
        // 1. 构建控制结构,父进程写入,子进程读取。
        vector<Endpoint> end_points;
        createProcesses(&end_points);
    
        // 2. 进程控制
        ctrlProcess(end_points);
    
        // 3. 处理所有的退出问题
        waitProcess(end_points);
        return 0;
    }

**随机派发任务：**

![在这里插入图片描述][abdd59f560b84a8e8ec2a88ff6989823.png]  
**用户派发指定任务**

![在这里插入图片描述][0d4c9b99a1764cde8c94132e28e236b0.png]

--------------------

## 三、命名管道 ##

匿名管道有一个 **`缺陷`** 就是：**只能在具有共同祖先（具有亲缘关系）的进程间通信**。如果我们想要让两个毫不相干的进程进行通信，可以使用FIFO文件来实现，他就是 **`命名管道`**。

**命名管道的创建：**

mkfifo named_pipe

![在这里插入图片描述][2fae0722aa8543ddab944a497b90cd58.png]

**往管道里面写入数据 / 从管道中读取数据**

![在这里插入图片描述][6d75df1a01ec4718821a42b82bb00713.png]

**原理如下：**

两个进程打开同一个文件，站在内核的角度，第二个文件不需要再被创建struct file对象，因为OS会识别到打开的文件被打开了。在内核中，此时就看到了同一份资源，有着操作方法和缓冲区，不需要把数据刷新到磁盘上去，所以无论是匿名还是命名管道，本质上都是管道。

![在这里插入图片描述][976121d6c5ed4d31af9ad652266bfb5d.png]

`匿名管道`：通过继承的方式看到同一份资源。  
`命名管道`：通过让不同的进程打开指定名称（路径+文件名，具备唯一性）的同一个文件看到同一份资源，所以命名管道是通过文件名来标定唯一性的。而匿名管道是通过继承的方式来标定的。

--------------------

### 命名管道模拟客户端和服务端 ###

创建一个管道文件，让读写端进程分别按照自己的需求打开文件，然后进行通信。

**makefile**

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

**comm.hpp**

#pragma once
    
    #include <iostream>
    #include <string>
    
    #define NUM 1024
    
    const std::string fifoname = "./fifo";
    uint32_t mode = 0666;

**server.cc**

![在这里插入图片描述][c1e8cab4d0c74041ab4e6031b36e762f.png]

**client.cc**

![在这里插入图片描述][7c337cbbf6b84f96824cf61aa60f2112.png]

**运行结果：**

![在这里插入图片描述][ff7f04d9900847379927dda817f0fc86.png]

**匿名管道和命名管道的区别**

>  *  匿名管道由pipe函数创建并打开
>  *  命名管道由mkfifo函数创建，打开用open
>  *  FIFO（命名管道）和 pipe（匿名管道）之间唯一的区别在于它们创建和打开的方式不同，一旦这些工作完成之后，他们具有相同的语义。

--------------------

[e7eaf4a45a224798a877793ff54ea497.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/4f9e8708bb634ee7a413afc99fede3cd.png
[3ed5f9e701ce43579ecb4f036b96e64c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/29040ebfcec349929c79f62756f1b981.png
[61f97097932343d09caaa2337eccd12b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/13c67c6a59a24db984cf577e47f9aff1.png
[7898a2fe0f9545748b284e049832b1d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/28740f834a6e417d870b4dbcc4db01a7.png
[f3793f1c119e4228b8592b79e1822463.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/412455fdbaee4c91a4f7a54babb6ab6d.png
[9225f6e29ff34cd5a00c0c438bee0efa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/ba1d3a85d2c54f458d3f2b3a9bf1bb6a.png
[dd86c8262e404cd892d3ae9e2d26743a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/2e31ae05c9c2440db030629eaf4b63a6.png
[c9736645b6074041bf1919235cd4dfdf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/f7640693e4b644fb8fbe63739e1b3f2b.png
[1ab229b0dc4343b78650dcab5c7f9d8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/ea5295061b6a48f5b9fbb82413c7afd4.png
[5dc7069724a3452687a936323b54e9ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/4764ca0a5ee44b0185babbc225851bb0.png
[2c96c6e7fa1d438e961c22ca5b486aef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/08dd470d613641ab8f6e18470c46c1d4.png
[a4c1f0a9816a476589d873546ccebf9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/2be79f6c4c8f4634be8b20b3fc0c2544.png
[abdd59f560b84a8e8ec2a88ff6989823.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/425ffda34ba5486ca6b865ae08aedfad.png
[0d4c9b99a1764cde8c94132e28e236b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/c8eb662d72be4eac80de0c705d84663b.png
[2fae0722aa8543ddab944a497b90cd58.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/c240e1d70fe24ff0b91e4cdc475575f3.png
[6d75df1a01ec4718821a42b82bb00713.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/e7aafc7caf7a4f18bb75856abfb90668.png
[976121d6c5ed4d31af9ad652266bfb5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/42a862578ea740899d4d481c938f8c5d.png
[c1e8cab4d0c74041ab4e6031b36e762f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/ad96edf2e88d4eff923c0e9218b6966f.png
[7c337cbbf6b84f96824cf61aa60f2112.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/7549dddde3fe498aafdc07341accd34e.png
[ff7f04d9900847379927dda817f0fc86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/5784dcaa352545e89805dabb106e77f6.png