Linux---进程间通信 | 管道 | PIPE | MKFIFO | 共享内存 | 消息队列

管道

管道是UNIX中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的数据流称为一个管道。

一个文件，可以被多个进程打开吗？可以，那如果一个进程打开文件，往文件里面写数据，另一个进程打开文件，读取文件里面的数据。这样可以把文件写到磁盘上，进行读写操作。在之前，我们就用过管道的操作。

ps -ajx | head -1

比如说这个查看进程的指令。在进程那篇文章里进程使用。

ps -ajx是一个指令，在运行的时候就变成了一个进程。head -1也会变成一个进程。| 是管道。

曾经我们说过，每一个进程都有一个tack_struct，每一个文件再打开的时候，会有文件描述符，文件描述符在文件描述符表中。task_struct 中会有指针指向文件描述符表。

进程打开文件的之后，都要有struct file对象。默认会打开三个文件---标准输入，标准输出，标准错误。

再打开一个新文件的时候，系统会自动的查找文件描述符表，将最小的文件描述符给新打开的文件。

将新打开的文件的地址填入到文件描述符表中，然后将3号位置返回给fd。

进程间通信的本质前提是需要先让不同的进程，看到同一份资源。这样就可以完成进程间的通信了。

管道其实就是文件，只不过，这个文件不是磁盘文件。

既然父子进程之间资源是共享的，那么子进程关闭fd=0的文件，子进程会受到影响吗？其实不会，因为struct file中是存在一个引用计数器的概念的。

匿名管道

父进程想写数据，就把读端关掉了，子进程要读数据，就把写端关掉了，这样就形成了一个单项连同的管道了。

include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码
#include <iostream>
#include <unistd.h>int main()
{int fd[2];pipe(fd);pid_t id = fork();if (id > 0){close(fd[0]);std::string msg = "hello world";write(fd[1], msg.c_str(), msg.size());}else if (id == 0){close(fd[1]);char msg[1024];read(fd[0], msg, 1024);std::cout << std::string(msg) << std::endl;}return 0;
}

这样就能完成两个进程间的通信了。

但是，pipe只能完成具有血缘关系(父子，爷孙，兄弟，只不过常用来完成父子间的通信)的进程通信。因为父子间的资源是共享的，两个互不相干之间的资源可不是共享的。

代码中的管道是没有名字的，所以称他为匿名管道。

管道的特征

  1. 具有血缘关系的进程进行进程间通信
  2. 管道只能单向通信
  3. 父子进程是会进程协同的，同步与互斥的 --- 保护管道文件的数据安全
  4. 管道是面向字节流的
  5. 管道是基于文件的，而文件的生命周期是随进程的

管道的四种情况

  1. 读写端正常，管道如果为空，读端就要阻塞
  2. 读写段正常，管道如果被写满，写端就要阻塞
  3. 读端正常读，写端关闭，读端就会读到0，表明读到了文件pipe结尾，不会被阻塞
  4. 写端正常写入，读端关闭了。操作系统就要杀掉正在写入的进程。(通过信号杀掉)

命名管道

| 是一种管道，还有一种管道是 mkfifo

mkfifo可以完成两个互不相关进程间的通信。

创建管道文件后往管道文件中写内容，会造成阻塞。

此时我们通过另一个窗口将管道中的数据读取出来，阻塞的那一端也会放开。

#include<sys/types.h>
#include<sys/stat.h>
int mkfifo(const char * pathname,mode_t mode);
参数一：创建管道的名字
参数二：文件的权限
返回值：成功0，失败-1
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>int main()
{// 创建管道文件int n = mkfifo("MYMKFIFO", 0664);if (n < 0){std::cerr << "mkfifo" << std::endl;exit(-1);}// 打开文件int fd = open("MYMKFIFO",O_RDWR);if (fd < 0){std::cerr << "open" << std::endl;}// 向管道文件中写入内容std::string line;while (true){std::cout << "Please Enter@ ";std::cin >> line;write(fd, line.c_str(), line.size());}close(fd);// 删除管道sleep(5);n = unlink("MYMKFIFO");if (n < 0){std::cerr << "unlink" << std::endl;exit(-1);}return 0;
}

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>int main()
{int fd = open("MYMKFIFO", O_RDWR);if (fd < 0){std::cerr << "open" << std::endl;exit(-1);}std::string line;while (true){char buf[1024];int n = read(fd, buf, 1024);if (n == -1){break;}std::cout << std::string(buf) << std::endl;}close(fd);return 0;
}
.PHONY:all
all:mypipe mymkfifo
mypipe:mypipe.ccg++ -o $@ $^
mymkfifo:mymkfifo.ccg++ -o $@ $^.PHONY:clean
clean:rm  mypipe mymkfifo

这样，就完成了两个进程间的通信。

共享内存

每一个进程都有自己对应的内核数据结构，内核数据结构中的指针指向一个页表，通过页表的映射关系来找到物理内存，另一个进程也是通过页表的映射，来找到物理内存，那么理论上这两个进程就可以找到物理内存中的同一块内存来完成共享内存。当然，这些操作不会是进程直接做的，是由操作系统来完成。如何管理共享内存呢？先描述，在组织。

这块共享内存有多少进程关联起来了？这块内存多大？这就由一个内核结构体来描述共享内存了，经过操作系统操作后，最后都会变成对某一个数据结构的增删查改。

下面就是对一些函数的理解了。

shmget(创建共享内存)

功能：用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);
参数
key:这个共享内存段名字
size:共享内存大小(单位是字节)
shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1IPC_CREAT(单独使用):如果你创建的共享内存不存在，就创建，存在，就获取并返回。IPC_CREAT | IPC_EXCL:如果你创建的共享内存不存在，就创建，存在，就出错返回。确保如果我们申请陈工了一个共享内存，这个共享内存一定是一个新的IPC_EXCL:不单独使用

其实还有点问题，如何知道这个共享内存是否存在？如果保证让不同的进程看到同一个共享内存呢？

通过key这个参数可以完成。

  1. key是一个数字，这个数字是几，不重要。关键在于它必须在内核中具有唯一性，能够让不同的进程进行唯一性标识。
  2. 第一个进程可以通过key创建共享内存，第二个之后的进程，只要拿着同一个key 就可以和第一个进程看到同一个共享内存了。
  3. 对于一个已经创建好的共享内存，key在哪？共享内存是由操作系统创建的，操作系统要对共享内存进行管理，所以key在共享内存的描述对象中。
  4. 第一次创建的时候，必须有一个key了。如何形成一个key？通过ftok这个系统调用接口。
  5. key跟路径有点类似，是唯一的。

这个ftok不会在内存中去遍历key，找到一个没有使用过的key，它内置的有一套算法，由pathname和proj_id进行了数值计算即可。这两个参数由用户自己决定。

#include "comm.hpp"int main()
{int shmid = CreateShm();return 0;
}
#ifndef __COMM_HPP__
#define __COMM_HPP__#include <iostream>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <cstring>
#include <unistd.h>
#include "/home/sxk/mylog/log.hpp"const std::string pathname = "/home/sxk";
const int proj_id = 0x777777;
const int size = 4096;key_t GetKey()
{/*通过ftok创建出一个唯一的key*/key_t k = ftok(pathname.c_str(), proj_id);if (k < 0){std::cerr << "ftok fail" << std::endl;exit(1);}std::cout << "ftok success, key :" << k << std::endl;return k;
}int GetShareMemHelper(int flag)
{/*用key创建出一块共享内存*/key_t k = GetKey();int shmid = shmget(k, size, flag);if (shmid < 0){std::cerr << "shmget fail" << std::endl;exit(2);}std::cout << "ftok success, shmid :" << shmid << std::endl;return shmid;
}int CreateShm()
{return GetShareMemHelper(IPC_CREAT | IPC_EXCL | 0666);
}int GetShm()
{return GetShareMemHelper(IPC_CREAT);
}#endif
.PHONY:all
all:proca procbproca:proca.ccg++ -o $@ $^ -g -std=c++11
procb:procb.ccg++ -o $@ $^ -g -std=c++11.PHONY:clean
clean:rm -f proca procb

运行之后可以发现,key为1996557648，操作系统内标定的唯一性,shmid为15，只在你的进程内，用来表示资源的唯一性。

当我们再次运行这个程序的时候，就会出现错误。

通过 ipcs -m可以查看共享内存资源。

此时可以看到，我们的进程已经退出了，但是资源还是存在。说明用户如果不主动关闭，共享内存会一直存在。除非内核重启或者用户关闭。

通过 ipcrm -m可以删除共享内存资源。 ipcrm -m shmid

关掉之后在运行代码。

共享内存在创建的时候还有一个权限的问题，毕竟总会存在不同的进程对数据有不同的需求。

所以在shmget的时候，可以shmget(k, size, IPC_CREAT | IPC_EXCL | 0666)，0666跟open打开文件，若文件不存在则创建文件的权限设置一样。

共享内存的大小一般建议是4096的整数倍。如果大小给4097，实际上操作系统给你的是4096 * 2的大小。

shmat(挂接)

功能：将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数
shmid: 共享内存标识
shmaddr:指定连接的地址
shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1(跟malloc有点相似)---
shmaddr为NULL，核心自动选择一个地址(一般设置为null就行)
shmaddr不为NULL且shmflg无SHM_RND标记，则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记，则连接的地址会自动向下调整为SHMLBA的整数倍。公式：shmaddr -
(shmaddr % SHMLBA)
shmflg=SHM_RDONLY，表示连接操作用来只读共享内存
#include "comm.hpp"int main()
{int shmid = CreateShm();std::cout << "creat shm done" << std::endl;sleep(3);char * shmaddr = (char*)shmat(shmid, nullptr, 0);sleep(5);return 0;
}

添加挂接之后。

会发现，nattch由0变成1，nattch代表的就是挂接数量。

shmdt(脱离)

功能：将共享内存段与当前进程脱离
原型
int shmdt(const void *shmaddr);
参数
shmaddr: 由shmat所返回的指针
返回值：成功返回0；失败返回-1
注意：将共享内存段与当前进程脱离不等于删除共享内存段

既然能挂接，那么也一定可以脱离。

#include "comm.hpp"int main()
{int shmid = CreateShm();std::cout << "creat shm done" << std::endl;sleep(3);char * shmaddr = (char*)shmat(shmid, nullptr, 0);sleep(3);int n = shmdt((void*)shmaddr);if (n < 0){std::cerr << "shmdt fail " << std::endl;}sleep(5);return 0;
}

可以观察到，nattch由0->1->0。

shmctl

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

命令

说明

IPC_STAT

把shmid_ds结构中的数据设置为共享内存的当前关联值

IPC_SET

在进程有足够权限的前提下，把共享内存的当前关联值设为shmid_ds数据结构中给出的值

IPC_RMID

删除共享内存段

#include "comm.hpp"int main()
{int shmid = CreateShm();std::cout << "creat shm done" << std::endl;sleep(3);char * shmaddr = (char*)shmat(shmid, nullptr, 0);sleep(3);int n = shmdt((void*)shmaddr);if (n < 0){std::cerr << "shmdt fail " << std::endl;}sleep(5);shmctl(shmid, IPC_RMID, nullptr);return 0;
}

这样就完成了删除的操作。

实现两个进程间的通信

#include "comm.hpp"int main()
{int shmid = CreateShm();    char* shmaddr = (char*)shmat(shmid, nullptr, 0);if (*(int*)shmaddr == -1){perror("shmat");exit(-1);}while (true){std::cout << "client say@ " << shmaddr << std::endl;sleep(1);}shmdt((void*)shmaddr);shmctl(shmid, IPC_RMID, nullptr);return 0;
}
#include "comm.hpp"int main()
{int shmid = GetShm();    char* shmaddr = (char*)shmat(shmid, nullptr, 0);if (*(int*)shmaddr == -1){perror("shmat");exit(-1);}while (true){fgets(shmaddr, 4096, stdin);}shmdt((void*)shmaddr);return 0;
}

共享内存的特性

  1. 共享内存没有同步互斥之类的保护机制
  2. 共享内存是进程间通信中，速度最快的
  3. 共享内存内部的数据，由用户自己维护

SISTEM V 消息队列

所谓的消息队列，还是由操作系统创建的。

要想通过消息队列进行通信，那么必须得先让两个进程看到同一份资源，这份资源可以是文件缓冲区或者内存块或者是队列。进程看到的资源不同，通信的方式也不同。

共享内存是先要让不同的进程看到同一块共享内存，也就是找到唯一的key，消息队列跟它一样，要先让两个不同的进程看到同一个队列。然后不同的进程可以向内核中发送数据块。那么，进程A发送数据块，进程B也发送数据块，如何区分AB进程的数据块呢？向内核中发送带类型的数据块。有了类型，就可以区分不同的进程了。这个队列是要由操作系统创建，当创建了n个消息队列之后，操作系统要对消息队列进行管理，其实就是对某一个数据结构的增删查改的管理。

msgget(创建)

key如何来？还是通过ftok，msgflg的用法跟共享内存中的shmget参数中的msgflg用法一样。
返回值：
如果成功，返回所创建的消息队列的ID，失败则返回-1

msgctl(删除)

用法跟共享内存中的shmctl一样，用来删除共享内存的(第二个参数置为 IPC_RMID)。

msgsnd(发送数据块)

msgsnd
参数一：消息队列ID
参数二：提供对应的缓冲区，因为要发送数据
参数三：发送数据的大小
参数四：默认为0就行了msgrcv
参数一：消息队列ID
参数二：提供对应的缓冲区，因为要接受数据
参数三：接受数据的大小
参数四：对应的消息类型
参数四：默认为0就行了

消息队列的接口跟共享内存的接口用法基本类似。

通过 ipcs -q可以查看所创建的消息队列

通过 ipcrm -q可以删除所创建的消息队列

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/450285.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【服务器】RAID（独立磁盘冗余阵列）

【服务器】RAID（独立磁盘冗余阵列）

RAID&#xff08;独立磁盘冗余阵列&#xff09; 一、RAID的介绍二、RAID的分类#2-1 RAID 02-2 RAID 1#2-3 RAID 32-4 RAID 52-5 RAID 62-6 RAID 10(先做镜像&#xff0c;再做条带化)2-7 RAID 01&#xff08;先做条带&#xff0c;再做镜像&#xff09;2-8 RAID比较 三、磁盘阵列…
阅读更多...
设备的层次结构 - 驱动程序的复杂层次结构

设备的层次结构 - 驱动程序的复杂层次结构

由于设备对象的水平结构和垂直结构&#xff0c;组成了Windows设备的树形结构图。在Windows中出事的时候会有一个根设备&#xff0c;为了理解简单&#xff0c;我们将PCI总线想象成根总线&#xff08;根总线其实不是PCI总线&#xff0c;只是为了理解方便&#xff09;。查到PCI总线…
阅读更多...
【云原生】Docker如何构建镜像

【云原生】Docker如何构建镜像

目录 前言 一、基于已有的镜像创建 步骤一&#xff1a;先基于现有的镜像创建一个容器&#xff0c;然后进入容器去完成修改 步骤二&#xff1a;将该容器作为一个模板提交创建为一个新的镜像 步骤三&#xff1a;基于新的镜像&#xff0c;docker run创建一个容器&#xff0c;进…
阅读更多...
leetcode刷题(剑指offer) 297.二叉树的序列化和反序列化

leetcode刷题(剑指offer) 297.二叉树的序列化和反序列化

297.二叉树的序列化与反序列化 序列化是将一个数据结构或者对象转换为连续的比特位的操作&#xff0c;进而可以将转换后的数据存储在一个文件或者内存中&#xff0c;同时也可以通过网络传输到另一个计算机环境&#xff0c;采取相反方式重构得到原数据。 请设计一个算法来实现…
阅读更多...
C#，雅各布斯塔尔—卢卡斯（Jacobsthal Lucas Number）的算法与源代码

C#，雅各布斯塔尔—卢卡斯（Jacobsthal Lucas Number）的算法与源代码

1 雅各布斯塔尔序列 雅各布斯塔尔序列是一个与斐波那契序列类似的加法序列&#xff0c;由递归关系JnJn-12Jn-2定义&#xff0c;初始项J00&#xff0c;J11。序列中的一个数字称为雅可布沙尔数。它们是卢卡斯序列Un&#xff08;P&#xff0c;Q&#xff09;的一种特殊类型&#x…
阅读更多...
【CSS】文本溢出省略的两种方式

【CSS】文本溢出省略的两种方式

【CSS】文本溢出省略的两种方式 假设有一个卡片组件&#xff0c;组件里的内容有长有短&#xff0c;我们希望在内容很长的时候省略文字&#xff0c;以保证卡片的高度不会过高。 单行文本 要实现在文字超出时不显示超出部分&#xff0c;并用省略号表示还有更多文字&#xff0…
阅读更多...
alibabacloud学习笔记05（小滴课堂）

alibabacloud学习笔记05（小滴课堂）

高并发下的微服务存在的问题 高并发下的微服务容错方案 介绍什么是分布式系统的流量防卫兵Sentinel 微服务引入Sentinel和控制台搭建 每个服务都加上这个依赖。 启动方式&#xff1a; 讲解AliababCloud微服务整合Sentinel限流配置实操 我们在order和video模块都加上。 分别启动…
阅读更多...
【数据结构】二叉树链式结构的实现

【数据结构】二叉树链式结构的实现

简单不先于复杂&#xff0c;而是在复杂之后。 文章目录 1. 二叉树链式结构的实现1.1 前置说明1.2 二叉树的遍历1.2.1 前序、中序以及后序遍历1.2.2 层序遍历 1.3 节点个数以及高度等1.4 二叉树基础oj练习1.5 二叉树的创建和销毁 1. 二叉树链式结构的实现 1.1 前置说明 在学习二…
阅读更多...
【python】python爱心代码

【python】python爱心代码

一、实现效果&#xff1a; 欢迎来到英杰社区https://bbs.csdn.net/topics/617804998 二、准备工作 &#xff08;1)、导入必要的模块&#xff1a; 代码首先导入了需要使用的模块&#xff1a;requests、lxml和csv。 import requests from lxml import etree import csv 如果出现…
阅读更多...
Autosar 网络管理 NM

Autosar 网络管理 NM

为什么要网络管理 Autosar网络管理之所以重要&#xff0c;可以用比较通俗的话来解释&#xff1a; 想象一下汽车是一个庞大的交流团队&#xff0c;每个成员都是一部分的电子控制单元&#xff08;ECU&#xff09;。这些成员之间需要不断地交换信息&#xff0c;就像团队成员需要…
阅读更多...
JSR303参数校验-SpringMVC

JSR303参数校验-SpringMVC

文章目录 JSR303技术标准简介JSR303标准几个具体实现框架validation-apijakarta.validation-apihibernate-validatorspring-boot-starter-validation Spring Validationjavax.validation.constraints包下提供的注解org.hibernate.validator.constraints包扩展的注解校验注解默认…
阅读更多...
基于控制台的购书系统（Java 语言实现）

基于控制台的购书系统（Java 语言实现）

&#x1f4da;博客主页&#xff1a;爱敲代码的小杨. ✨专栏&#xff1a;《Java SE语法》|《数据结构与算法》 ❤️感谢大家点赞&#x1f44d;&#x1f3fb;收藏⭐评论✍&#x1f3fb;&#xff0c;您的三连就是我持续更新的动力❤️ &#x1f64f;小杨水平有限&#xff0c;欢…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023