【Linux】进程间通信之共享内存/消息队列/信号量

这篇具有很好参考价值的文章主要介绍了【Linux】进程间通信之共享内存/消息队列/信号量。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、共享内存的概念及原理

共享内存是通过让不同的进程看到同一个内存块的方式。

我们知道,每一个进程都会有对应的PCB-task_struct ,独立的进程地址空间,然后通过页表将地址映射到物理内存中。此时我们就可以让OS在内存中申请一块空间,然后将创建好的内存空间映射到进程的地址空间中,两个需要进行通信的进程经过映射之后就看到了同一块内存空间,在未来两个进程不想进行通信之后,取消进程和内存的映射关系—去关联,然后释放内存即可。

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

我们需要注意的是,进程地址空间,是专门设计的,用来IPC,共享内存是一种通信方式,所以想通信的进程,都可以使用,那么OS中一定会同时存在很多的共享内存。

二、共享内存相关接口说明

1.shmget函数

功能:用来创建共享内存
原型
int shmget(key_t key, size_t size, int shmflg);
头文件
#include <sys/ipc.h>
#include <sys/shm.h>
参数
key:这个共享内存段名字
size:共享内存大小
shmflg:由九个权限标志构成,它们的用法和创建文件时使用的mode模式标志是一样的
其中最常用的两个标志位:
IPC_CREAT:如果文件不存在就创建,存在就获取
IPC_EXCL:无法单独使用,IPC_CREAT | IPC_EXCL,如果不存在就创建,如果存在就出错返回,这样就保证如果创建成功,一定是一个新的shm
返回值:成功返回一个非负整数,即该共享内存段的标识码;失败返回-1

2.ftok函数

功能;获取key
原型
key_t ftok(const char *pathname, int proj_id);
头文件
#include <sys/types.h>
#include <sys/ipc.h>
参数
pathname:文件名
proj_id:非0整数,用于形成key
返回值:成功返回key,失败返回-1,错误码被设置

我们在申请内存使用malloc函数需要告诉要申请多大的空间,而释放的时候只需要告诉内存的起始地址即可,那么操作系统是如何知道我们申请了多大的内存呢,实际上,我们在申请内存的时候,OS为我们提供了申请的空间和该空间的属性,如大小等等。一个程序多次申请空间,那么操作系统就需要将这些空间管理起来,管理的方法是先描述再组织,描述的对象的就是这些空间的属性。共享内存也是如此,OS先描述再组织,所以共享内存=共享内存块+共享内存的相关属性。那么我们创建共享内存的时候,如何保证共享内存在系统中是唯一的,答案是通过key来进行唯一标识,那么key在哪呢,key在共享内存的属性struct shm{key_t key;};中

3.shmat函数

功能:将共享内存段连接到进程地址空间
原型
void *shmat(int shmid, const void *shmaddr, int shmflg);
头文件
#include <sys/types.h>
#include <sys/shm.h>
参数
shmid: 共享内存标识
shmaddr:指定连接的地址
shmflg:它的两个可能取值是SHM_RND和SHM_RDONLY
返回值:成功返回一个指针,指向共享内存第一个节(起始地址);失败返回-1
shmaddr为NULL,核心自动选择一个地址
shmaddr不为NULL且shmflg无SHM_RND标记,则以shmaddr为连接地址。
shmaddr不为NULL且shmflg设置了SHM_RND标记,则连接的地址会自动向下调整为SHMLBA的整数倍。公式:shmaddr - 
(shmaddr % SHMLBA)
shmflg=SHM_RDONLY,表示连接操作用来只读共享内存

4.shmdt函数

功能:将共享内存段与当前进程脱离
原型
int shmdt(const void *shmaddr);
头文件
#include <sys/types.h>
#include <sys/shm.h>
参数
shmaddr: 由shmat所返回的指针
返回值:成功返回0;失败返回-1
注意:将共享内存段与当前进程脱离不等于删除共享内存段

5.shmctl函数

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

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

三、用共享内存实现server&client通信

1.shm_server.cc

#include "comm.hpp"

int main()
{
    key_t key = getkey();
    printf("key:0x%x\n", key);
    int shmid = createShm(key);
    printf("shmid:%d\n", shmid);

    char *start = (char *)attachShm(shmid);
    printf("attach success, address start: %p\n", start);

    while (true)
    {
        printf("client say : %s\n", start);
        // struct shmid_ds ds;
        // shmctl(shmid, IPC_STAT, &ds);
        // printf("获取属性: size: %d, pid: %d, myself: %d, key: 0x%x",
        //        ds.shm_segsz, ds.shm_cpid, getpid(), ds.shm_perm.__key);
        sleep(1);
    }

    // 去关联
    detachShm(start);

    // 删除共享内存
    delShm(shmid);
    return 0;
}

2.shm_client.cc

#include "comm.hpp"

int main()
{
    key_t key = getkey();
    printf("key:0x%x\n", key);
    int shmid = getShm(key);
    printf("shmid:%d\n", shmid);

    char *start = (char *)attachShm(shmid);
    printf("attach success, address start: %p\n", start);

    const char *message = "hello server, 我是另一个进程,正在和你通信";
    pid_t id = getpid();
    int cnt = 1;
    // char buffer[1024];
    while (true)
    {
        snprintf(start, MAX_SIZE, "%s[pid:%d][消息编号%d]", message, id, cnt++);
        // snprintf(buffer, sizeof(buffer), "%s[pid:%d][消息编号:%d]", message, id, cnt++);
        // memcpy(start, buffer, strlen(buffer)+1);
        // pid, count, message
        sleep(1);
    }

    detachShm(start);

    return 0;
}

3.comm.hpp

#ifndef __COMM_HPP_
#define __COMM_HPP_

#include <iostream>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/ipc.h>

#define PATHNAME "."
#define PROJ_ID 0x666

// 共享内存的大小,一般建议是4KB的整数倍
// 系统分配共享内存是以4KB为单位的! --- 内存划分内存块的基本单位Page
#define MAX_SIZE 4096 // --- 内核给你的会向上取整, 内核给你的,和你能用的,是两码事

key_t getkey()
{
    key_t key = ftok(PATHNAME, PROJ_ID);
    if (key == -1)
    {
        std::cerr << "error" << strerror(errno) << std::endl;
        exit(1);
    }

    return key;
}

int getShmHelper(key_t key, int flags)
{
    int shmid = shmget(key, MAX_SIZE, flags);
    if (shmid < 0)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        exit(2);
    }

    return shmid;
}

int getShm(key_t key)
{
    return getShmHelper(key, IPC_CREAT);
}

int createShm(key_t key)
{
    return getShmHelper(key, IPC_CREAT | IPC_EXCL | 0600);
}

void *attachShm(int shmid)
{
    void *mem = shmat(shmid, nullptr, 0);
    if ((long long)mem == -1L)
    {
        std::cerr << "shmat:" << errno << ":" << strerror(errno) << std::endl;
        exit(3);
    }

    return mem;
}

void detachShm(void *start)
{
    if (shmdt(start) == -1)
    {
        std::cerr << "shmdt:" << errno << ":" << strerror(errno) << std::endl;
    }
}

void delShm(int shmid)
{
    if (shmctl(shmid, IPC_RMID, nullptr) == -1)
    {
        std::cerr << "shmctl:" << errno << ":" << strerror(errno) << std::endl;
    }
}
#endif

4.查看ipc资源及其特征

查看IPC资源的指令

ipcs -m/-q/-s
分别查看共享内存/消息队列/信号量
删除使用  ipcrm -m shmid

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

IPC资源的特征

共享内存的生命周期是随OS的,不是随进程的

我们使用ctrl C终止程序之后,第二次显示文件存在

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

5.共享内存的优缺点

优点:在所有进程间通信中是最快的,能大大的减少数据拷贝的次数

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间,这些进程间数据传递不再涉及到

内核,换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

同样的代码,如果用管道来实现,综合考虑管道和共享内存,考虑键盘输入和显示器输出,共享内存和管道各有几次数据拷贝

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

对于管道,我们将输入的数据线拷贝到我们自己定义的缓冲区buffer中,然后通过系统调用write写到管道中,然后通过read读到自己定义的缓冲区buffer中,然后再拷贝到显示器上,这里我们不考虑输入时从键盘到stdin的拷贝,stdout到显示器的拷贝,所以管道一共需要拷贝4次

对于共享内存,我们只需要将数据拷贝到共享内存中,然后从共享内存中拷贝到显示器上,同样这里不考虑键盘到stdin,stdout到显示器的拷贝,所以一共需要拷贝2次

缺点:不能进行同步和互斥操作,没有对数据做任何保护

6.共享内存的数据结构

struct shmid_ds {
 struct ipc_perm shm_perm; /* operation perms */
 int shm_segsz; /* size of segment (bytes) */
 __kernel_time_t shm_atime; /* last attach time */
 __kernel_time_t shm_dtime; /* last detach time */
 __kernel_time_t shm_ctime; /* last change time */
 __kernel_ipc_pid_t shm_cpid; /* pid of creator */
 __kernel_ipc_pid_t shm_lpid; /* pid of last operator */
 unsigned short shm_nattch; /* no. of current attaches */
 unsigned short shm_unused; /* compatibility */
 void *shm_unused2; /* ditto - used by DIPC */
 void *shm_unused3; /* unused */
};

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

struct shmid_ds结构体中包含了struct ipc_perm结构体,其中就包含了key

四、system V消息队列

消息队列就是内核提供了队列这种数据结构用于进程间通信,两个进程可以相互通信,队列的每一个节点包含了类型标识符,表示是各自读的数据还是写的数据

消息队列的接口如下:

int msgget(key_t key, int msgflg);
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);

消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法

每个数据块都被认为是有一个类型,接收者进程接收的数据块可以有不同的类型值特性方面

IPC资源必须删除,否则不会自动清除,除非重启,所以system V IPC资源的生命周期随内核

这里就不做过多的介绍了,消息队列我们了解即可。

五、system V信号量

信号量本质是一个计数器,通常用来表示公共资源中,资源数量的多少问题的。公共资源是被多个进程同时可以访问的资源。访问没有保护的公共资源,那么就会导致数据不一致的问题。

我们为什么要让不同的进程看到同一份资源呢,因为我们要进行通信,进程间实现协同,但是进程具有独立性,我们让进程看到就提出一些方法,但是又引入了一些新的问题(数据不一致问题)

我们未来将被保护起来的公共资源:临界资源,大部分是独立的

资源(内存,文件,网络等)是要被使用的,如何被进程使用呢,一定是该进程有对应的代码来访问这部分临界资源,这部分代码被称为临界区,其他的代码被称为非临界区

我们如何对数据进行保护呢:同步和互斥。互斥就是我在访问临界资源的时候,其他人不能够进行访问

原子性:要么不做,要做就做完,只有两态

为什么要有信号量呢?

我们举一个例子,我们在电影院看电影,我们不是只有坐在电影院对应的座位上的时候这个座位CIA属于我,而是我们买票的时候,就对放映厅中的座位进行了预定,此时座位就已经属于我们了。即当我们想要某种资源的时候,我们可以进行预定。假如放映厅有100个座位,那么电影院会不会卖出101张票呢,答案是不会,我们该如何做到呢。我们可以定义一个信号量,初始值为100,卖出一张票就-1,为0的时候就停止售票

信号量sem=100
sem--;//预定资源   --- P操作
访问公共资源
sem++;//释放公共资源  --- V操作

所以的进程在访问公共资源之前,都必须先申请sem信号量 ->先申请信号量的前提,是所有进程都必须先看到同一个信号量 ->信号量本身就是公共资源 -> 信号量本身也要保证自身的安全,–,++ ->信号量必须保证自身操作的安全性,–,++操作是原子

共享资源可以被当做一个整体资源,也可以被划分为一个一个资源的子部分

当一个信号量的初始值为1的时候,那么该信号量我们称为二元信号量,具有互斥的功能

由于各进程要求共享资源,而且有些资源需要互斥使用,因此各进程间竞争使用这些资源,进程的这种关系为进程的互斥

系统中某些资源一次只允许一个进程使用,称这样的资源为临界资源或互斥资源。

在进程中涉及到互斥资源的程序段叫临界区

IPC资源必须删除,否则不会自动清除,除非重启,所以system V IPC资源的生命周期随内核

六、IPC资源的组织方式

我们可以发现system V三种方式的数据结构如下:

共享内存:

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

消息队列:

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

信号量:

【Linux】进程间通信之共享内存/消息队列/信号量,Linux系统编程,linux,服务器,共享内存,进程间通信,消息队列,信号量,ipc

我们发现,他们的接口的相似度非常高,这样说明他们都是system V方式的进程间通信

我们可以创建一个struct ipc_perm *perms[]的数组,用于存放struct ipc_perm

我们创建一个共享内存数据结构的对象 struct shmid_ds myshm,然后perms[0] = &myshm.shm_perm

创建一个消息队列的数据结构对象 struct msqid_ds mymsg, prems[1] = &mymsg.msg_perm

然后我们在获取共享内存的属性的时候,就可以通过如下的方式进行获取

(struct shmid_ds*)perms[0] ->其他属性

这是因为一个结构体的第一个成员的地址,在数字上,和结构体对象本身的地址数字是相等的

这种方式向C++的多态一样,数组中的对象为基类,具体的对象(共享内存,消息队列,信号量)为子类文章来源地址https://www.toymoban.com/news/detail-755248.html

到了这里,关于【Linux】进程间通信之共享内存/消息队列/信号量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Linux进程间通信【消息队列、信号量】

    ✨个人主页: 北 海 🎉所属专栏: Linux学习之旅 🎃操作环境: CentOS 7.6 阿里云远程服务器 在 System V 通信标准中,还有一种通信方式: 消息队列 ,以及一种实现互斥的工具: 信号量 ;随着时代的发展,这些陈旧的标准都已经较少使用了,但作为 IPC 中的经典知识,我们可

    2024年02月08日
    浏览(62)
  • 【Linux】System V 共享内存、消息队列、信号量

    🍎 作者: 阿润菜菜 📖 专栏: Linux系统编程 System V 共享内存是一种进程间通信的机制,它允许多个进程 共享一块物理内存区域 (称为“段”)。System V 共享内存的优点是效率高,因为进程之间不需要复制数据;缺点是 需要进程之间进行同步,以避免数据的不一致性 。 共

    2024年02月04日
    浏览(49)
  • 【C++】Windows下共享内存加信号量实现进程间同步通信

    目录 一,函数清单 1.CreateFileMapping 方法 2.OpenFileMapping 方法 3.MapViewOfFile 方法 4.UnmapViewOfFile 方法 5.CreateSemaphore 方法 6. OpenSemaphore 方法 7.WaitForSingleObject 方法 8.ReleaseSemaphore 方法 9.CloseHandle 方法 10.GetLastError 方法 二,单共享内存单信号量-进程间单向通信 共享内存管理文

    2024年02月08日
    浏览(41)
  • Linux进程间通信 - 信号(signal) 与 管道(pipe) 与 消息队列

    什么是进程间通信,就是进程与进程之间进行通信,互相发送消息;可以通过 信号 或者 管道 或者 消息队列 或者 信号量 去通信! 目录 一、信号 1. 信号简介  2. 都有那些信号? 3. 注册信号的函数 1). signal 2). sigaction (项目中强烈推荐使用) 4. 信号发送 1). kill 函数 2). alarm 函

    2024年02月01日
    浏览(40)
  • linux进程间通信(信号量)

    信号量是一个特殊的变量,程序对其访问都是原子操作,且只允许对它进行等待(即 P(信号变量))和发 送(即 V(信号变量))信息操作。最简单的信号量是只能取 0 和 1 的变量,这也是信号量最常见的一种形式, 叫做二进制信号量。而可以取多个正整数的信号量被称为通用信号

    2024年02月07日
    浏览(38)
  • 【Linux】进程间通信 -- 信号量

    信号量是什么? 本质是一个计数器,通常用来表示公共资源中,资源数量多少的问题 公共资源:能被多个进程同时可以访问的资源 访问没有保护的公共资源:数据不一致问题(比如我想写abc123,但是我123还没有写入,就读取了abc,可能数据分开会导致数据无意义) 为什么要

    2024年02月16日
    浏览(47)
  • 【Linux】进程间通信——System V信号量

    目录 写在前面的话 一些概念的理解 信号量的引入 信号量的概念及使用            System V信号量是一种较低级的IPC机制 ,使用的时候需要手动进行操作和同步。在现代操作系统中,更常用的是 POSIX信号量 (通过 sem_* 系列的函数进行操作)或更高级的同步原语(如互斥锁

    2024年02月11日
    浏览(47)
  • linux中互斥锁,自旋锁,条件变量,信号量,与freeRTOS中的消息队列,信号量,互斥量,事件的区别

    对于目前主流的RTOS的任务,大部分都属于并发的线程。 因为MCU上的资源每个任务都是共享的,可以认为是单进程多线程模型。 【freertos】003-任务基础知识 在没有操作系统的时候两个应用程序进行消息传递一般使用全局变量的方式,但是如果在使用操作系统的应用中用全局变

    2024年02月11日
    浏览(48)
  • Qt共享内存实现进程间消息队列

    在Qt 5.9中,可以使用Qt的跨进程通信机制来实现进程间的消息队列。这个机制是通过Qt的QSharedMemory、QSystemSemaphore和QSharedMemory类来实现的。 首先,你需要创建一个消息队列的服务器端和客户端。服务器端负责接收和处理消息,客户端负责发送消息。 服务器端的代码示例如下:

    2024年02月09日
    浏览(40)
  • 【Linux】详解进程通信中信号量的本质&&同步和互斥的概念&&临界资源和临界区的概念

             访问资源在安全的前提下,具有一定的顺序性,就叫做同步 。在多道程序系统中,由于资源有限,进程或线程之间可能产生冲突。同步机制就是为了解决这些冲突,保证进程或线程之间能够按照既定的顺序访问共享资源。同步机制有助于避免竞态条件和死锁(

    2024年04月25日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包