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

翻斗花园牛图图-

于 2024-07-06 23:17:57 发布

阅读量976

点赞数 16

文章标签： linux c++

本文链接：https://blog.csdn.net/m0_74515566/article/details/138180705

版权

一、进程间通信介绍

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

翻斗花园牛图图-

关注

16
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Linux——进程间通信一(共享内存、管道、systrem V)

什么是管道？一个文件打开两次，那么在操作系统中会有2个struct file 但是这两个struct file指向同一个缓冲区若父进程3为读端，4为写端，子进程也一样。那么子进程写入，父进程读取缓冲区内容，这是父子进程看到了同一块资源。这种基于文件的，让不同进程看到同一份资源的通信方式叫做管道管道只能被设计成单向通信。
复制链接

扫一扫