当前位置：首页 > article >正文

【Linux】IPC：匿名管道、命名管道、共享内存

article 2025/1/30 14:06:47

⭐️个人主页：@小羊 ⭐️所属专栏：Linux 很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

动图描述

1、管道

我们知道进程具有独立性，但是在一些场景中进程间也需要通信，那怎么实现进程间的通信呢？

进程间通信的核心是：由OS提供一份公共的内存资源。

进程间通过文件的内核缓冲区实现资源共享，这个过程并不需要磁盘参与，所以设计了一种内存级的文件来专门实现进程间通信，这个内存级文件就是管道。
什么是管道？

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

管道的原理：

管道只能进行单向通信。

必须要先打开文件，再创建子进程，不能先创建子进程，再打开文件。这个过程利用的是子进程会继承父进程相关资源的特性。

为什么父进程打开文件的时候必须要以“读写”方式打开，不能只读或只写？
因为父进程打开文件，创建子进程后，父子进程必须有一个写，一个读，不能两个都读或两个都写。

管道不需要路径，也就不需要名字，所以叫做匿名管道。

在这里插入图片描述

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    //1、创建管道
    int fds[2] = {0};
    int n = pipe(fds);
    if (n != 0)
    {
        cerr << "pipe error" << endl;
        return 1;
    }

    //2、创建子进程
    pid_t id = fork();
    if (id < 0)
    {
        cerr << "fork error" << endl;
        return 2;
    }
    else if (id == 0)
    {
        //子进程
        //3、关闭不需要的fd
        close(fds[0]);//0是读


        exit(0);
    }
    else
    {
        //父进程
        close(fds[1]);//1是写

        pid_t rid = waitpid(id, nullptr, 0);
        if (rid > 0)
        {
            cout << "father wait child success, id :" << rid << endl;
        }
    }
    return 0;
}

上面的操作只是让父子进程看到了同一份资源，但还没有实现通信。这个内存资源有OS提供，所以进程间通信也理应通过操作系统实现，也就是调用系统调用。

	//...
    else if (id == 0)
    {
        //子进程
        //3、关闭不需要的fd
        close(fds[0]);//0是读
        int cnt = 0;
        while (true)
        {
            string message = "hello world, hello ";
            message += to_string(getpid());
            message += ", ";
            message += to_string(cnt++);
            write(fds[1], message.c_str(), message.size());
            sleep(1);
        }
        exit(0);
    }
    else
    {
        //父进程
        close(fds[1]);//1是写
        char buffer[1024];
        while (true)
        {
            ssize_t n = read(fds[0], buffer, 1024);
            if (n > 0)
            {
                buffer[n] = 0;
                cout << "child->father, message: " << buffer << endl;
            }
        }
        pid_t rid = waitpid(id, nullptr, 0);
        if (rid > 0)
        {
            cout << "father wait child success, id :" << rid << endl;
        }
    }
    //...

子进程写，父进程读。看待父子进程，就像看待文件一样。

在上面子进程sleep的过程中，父进程在做什么呢？在阻塞等待。
父进程在读完了子进程的数据后，OS就不要父进程读了，让其进入阻塞状态，等待子进程再次写入。这是为了保护共享资源，防止子进程写了一半父进程就读，或者父进程读了一半子进程就写。这个过程是管道内部自己做的。

现象：

管道为空&&管道正常，read会阻塞（read是一个系统调用）。
管道为满（管道资源是有限的）&&管道正常，write会阻塞。
管道写端关闭&&读端继续，读端读到0，表示读到文件结尾。
管道读端关闭&&写端继续，OS杀掉写入的进程。

在这里插入图片描述

特性：

面向字节流。不关心对面是如何写的，按需读取。
用来进行具有血缘关系的进程，进行IPC，常用于父子。
文件的声明周期随进程，管道也是。
单向数据通信。
管道自带同步互斥等保护机制。

2、进程池

退出进程池
当关闭写端，读端读到0，表示读到文件结尾，则结束进程。即将父进程所有的读端关闭，则相应的子进程就会结束，最后再由父进程等待回收。

void CleanProcessPool()
{
    //virsion1
    for (auto &c : _channels)
    {
        c.Close();
    }
    for (auto &c : _channels)
    {
        pid_t rid = waitpid(c.GetId(), nullptr, 0);
        if (rid > 0)
        {
            cout << "child: " << rid << "wait...success" << endl;
        }
    }
}

：上面关闭读端和等待子进程为什么要分开，关一个等待一个行吗？

在这里插入图片描述

根据上面的分析，所有的子进程的file_struct都会指向第一个管道，越往后的子进程指向的管道越多。所以我们只是把master的file_struct中指向管道关闭，这个管道还有其他子进程的file_struct指向，因此读端不会读到0，子进程不会退出，就会一直阻塞。解决这个问题有两种办法：

1、倒着关闭
因为通过分析可知，越早创建的管道指向越多，最后一个管道只被指向一次，只要将最后一个进程关闭，则前面的所有管道被指向都会少1，因此倒着关闭就不会出现阻塞的问题。

//virsion2
for (int i = _channels.size()-1; i >= 0; i--)
{
    _channels[i].Close();
    pid_t rid = waitpid(_channels[i].GetId(), nullptr, 0);
    if (rid > 0)
    {
        cout << "child: " << rid << "wait...success" << endl;
    }
}

2、在子进程中关闭所有历史fd
因为父进程的3号文件描述符总为空，子进程只有3号文件描述符指向管道。在这之前子进程继承父进程对之前的管道的指向，所以只需要在子进程中把这些指向全部关掉就行。

在这里插入图片描述

// 3、建立通信信道
if (id == 0)
{
	//关闭历史fd
	for (auto &c : _channels)
	{
	    c.Close();
	}
	// 子进程
	//close(pipefd[1]);
	//dup2(pipefd[0], 0); // 子进程从标准输入读取
	//_work();
	//exit(0);
}

3、命名管道

我们知道了，匿名管道的原理，是让父子进程看到同一份资源，而父子进程看到同一份资源，是因为子进程继承了父进程的资源。所以不难得出，匿名管道两端必须是父子进程。而如果我们想在任意进程之间建立管道呢？首先可以肯定的是这任意两个进程之间也要能看到同一份资源，因为是任意进程之间所以这个资源不能继承而来，所以就牵扯出了命名管道。

匿名管道是内存级的虚拟文件，而命名管道是真实存在的文件。

在这里插入图片描述

可以看到管道文件fifo的大小依旧为0，所以两个进程间通信的数据并没有刷新保存到磁盘中。

命名管道的原理:
为什么叫做命名管道，因为有名字，是真实存在的文件，既然是真实存在的文件，就一定有路径+文件名，而路径+文件名具有唯一性。这样不同的进程可以用同一个文件系统路径标志同一个资源，也就是不同的进程看到了同一个资源。
命名管道和普通文件的区别：
这么看来命名管道和普通文件好像除了创建方式不同外也没多大区别，而普通文件好像也能实现进程间通信，但是普通文件有两个问题，我们往普通文件中写入的数据会被刷新到磁盘中保存，另外普通文件也没有被特殊保护，也就是我们可以往里写大量的数据，在写的过程中也有可能被其他进程读，这两个问题是命名管道需要重点处理的，所以命名管道和普通文件有很大的区别，是特殊设计的。
这个命名管道，该由谁创建？
公共资源：一般要让指定的一个进程现行创建。一个进程创建&&使用，另一个进程获取&&使用。