消息队列，共享内存，信号

已于 2024-09-19 22:15:48 修改
阅读量705 收藏 17
点赞数 10
文章标签： linux 运维 服务器
于 2024-08-14 22:16:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61965705/article/details/141199754
版权

1.IPC（进程通信）对象

 进程之间要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信机制。

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。
 

IPC对象：内存文件

ipcs 查看所有ipc对象的信息

ipcrm -Q/M/S Key 删除ipc对象的消息队列/共享内存/信号灯

ipcrm -q/m/s 消息队列ID/共享内存ID/信号灯ID

 ftok 函数是一个用于生成合法键值（KEY）的函数，通常用于创建 IPC 对象，如消息队列、共享内存和信号量的键值。它通过将文件路径名和项目ID结合起来生成一个唯一的键值。

    key_t ftok(const char *pathname, int proj_id);
    功能：
        创建一个IPC对象名称
    参数：
        pathname:文件的路径（路径不同，生成的对象也不同）
        proj_id:项目ID（8bits）
    返回值：
        成功返回IPC对象名称
        失败返回-1

2.消息队列

每个消息都有一个类型和内容，使得进程可以根据类型选择性地接收消息，消息队列提供一种带有数据标识的特殊管道。

   1.创建IPC对象名称 fork()
    2.创建消息队列 msgget

 int msgget(key_t key, int msgflg);
    功能：
        创建一个消息队列 
    参数：
        key:IPC对象名称 
        msgflg:消息队列属性
            IPC_CREAT：创建一个消息队列
            IPC_EXCL: 如果消息队列存在就报错
    返回值：
        成功返回消息队列ID
        失败返回 -1 


    3.发送消息msgsnd

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
      功能：
        向消息队列中发送消息
      参数：
        msqid:消息队列的ID号
        msgp:发送消息的内容
        msgsz:发送消息的大小
        msgflg:消息属性 默认为0 
      返回值：
        成功返回0
        失败返回-1 


    4.接收消息msgrcv 

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
      功能：
        从消息队列中接收消息
      参数:
        msqid:消息队列的ID号
        msgp:存放消息的空间首地址
        msgsz:最多接收消息的大小
        msgtyp:接收消息的类型 
        msgflg:消息属性 默认为0
      返回值：
        成功返回接收到数据的字节数 
        失败返回-1 


    5.消息队列销毁.msgctl 

int msgctl(int msqid, int cmd, struct msqid_ds *buf);
      功能:
        向消息队列发送命令
      参数:
        msqid:消息队列的ID号
        cmd:命令 
            IPC_STAT：获取消息队列的信息 
      返回值:
        成功返回0
        失败返回-1

练习：

#include "../head.h"

int main(void)
{
    key_t key;
    int msgid;
    int ret = 0;
    message_t sendmsg;

    //1.创建IPC对象 Key 值
    key = ftok("/", 'b');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建消息队列  
    msgid = msgget(key, IPC_CREAT | 0664);
    if (-1 == msgid)
    {
        perror("fail to shmget");
        return -1;
    }

    sendmsg.mtype = 100;
    fgets(sendmsg.mtext, sizeof(sendmsg.mtext), stdin);
    sendmsg.mtext[strlen(sendmsg.mtext)-1] = '\0';

    //3.发送消息
    ret = msgsnd(msgid, &sendmsg, sizeof(sendmsg.mtext), 0);
    if (-1 == ret)
    {
        perror("fail to msgsnd");
        return -1;
    }

    return 0;
}

#include "../head.h"

int main(void)
{
    key_t key;
    int msgid;
    ssize_t nsize = 0;
    message_t recvmsg;

    //1.创建IPC对象 Key 值
    key = ftok("/", 'b');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建消息队列 
    msgid = msgget(key, IPC_CREAT | 0664);
    if (-1 == msgid)
    {
        perror("fail to shmget");
        return -1;
    }

    //3.接收消息 
    nsize = msgrcv(msgid, &recvmsg, sizeof(recvmsg.mtext), 100, 0);
    if (-1 == nsize)
    {
        perror("fail to msgrcv");
        return -1;
    }

    //4.打印消息
    printf("RECV:%s\n", recvmsg.mtext);

    //5.删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

3.共享内存

 共享内存是效率最高的 IPC

       1.创建 key 值 fork()
       2.创建共享内存 shmget

int shmget(key_t key, size_t size, int shmflg);
          功能:
            创建一个共享内存
          参数:
            key:IPC对象名称
            size:共享内存的大小（PAGE_SIZE(4k) 的整数倍)
            shmflg:
                IPC_CREAT  创建 
                IPC_EXCL   如果存在就报错 
          返回值:
            成功返回共享内存ID号
            失败返回-1 
 


       3.映射共享内存  shmat

  void *shmat(int shmid, const void *shmaddr, int shmflg);
          功能:
            将地址映射到共享内存中
          参数:
            shmid:共享内存ID号
            shmaddr:
                NULL: 让系统选择一个合适的地址映射到共享内存中
            shmflg:
                属性,默认为0 
          返回值:
            成功返回映射到共享空间的地址
            失败返回NULL


       4.解除映射 shmdt

int shmdt(const void *shmaddr);
          功能:
            解除映射空间
          参数:
            shmaddr:映射到共享内存中的地址
          返回值:
            成功返回0 
            失败返回-1 


       5.销毁共享内存 shmctl

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
          功能:
            向共享内存发送命令
          参数:
            shmid:共享内存ID号
             cmd:命令
                IPC_RMID 删除
          返回值:
            成功返回0 
            失败返回-1 

练习：

#include "../head.h"

int main(void)
{
    int ret = 0;
    int shmid = 0;
    char *pshmaddr = NULL;

    //1.创建 key 值
    key_t key;

    key = ftok("/", 'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建共享内存
    shmid = shmget(key, 4096, IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }

    //3.映射共享内存空间
    pshmaddr = shmat(shmid, NULL, 0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }

    //4.从终端接收写入到共享内存中
    while (1)
    {
        gets(pshmaddr);
        if (!strcmp(pshmaddr, ".quit"))
        {
            break;
        }
    }

    //5.解除映射
    ret = shmdt(pshmaddr);
    if (-1 == ret)
    {
        perror("fail to shmdt");
        return -1;
    }

    return 0;
}
#include "../head.h"

int main(void)
{
    int ret = 0;
    int shmid = 0;
    char *pshmaddr = NULL;

    //1.创建 key 值
    key_t key;

    key = ftok("/", 'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建共享内存
    shmid = shmget(key, 4096, IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }

    //3.映射共享内存空间
    pshmaddr = shmat(shmid, NULL, 0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }

    while (1)
    {
        printf("内容:%s\n", pshmaddr);
        if (!strcmp(pshmaddr, ".quit"))
        {
            break;
        }
    }

    //4.解除映射
    ret = shmdt(pshmaddr);
    if (-1 == ret)
    {
        perror("fail to shmdt");
        return -1;
    }

    //5.删除共享内存 
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

4.信号灯（有名信号量数组）

它可以实现进程之间的同步与互斥，可以实现共享内存的同步

它通过管理一个计数器来控制对资源的访问 

   1.创建 key 值 fork()

   2.创建信号量数组  semget

 int semget(key_t key, int nsems, int semflg);   
        功能：
            创建信号量数组 
        参数： 
            key:IPC对象名称
            nsems:信号量个数
            semflg:信号量属性
                IPC_CREAT：创建一个信号量数组
        返回值：    
            成功返回0 
            失败返回-1 

        3.向信号灯发送命令 semctl（SETVAL可以完成初始化）

 int semctl(int semid, int semnum, int cmd, ...);
        功能:
            向信号灯发送命令
        参数:

                   semid             信号量 ID
                  semnum         信号量元素序号（数组下标）

                  cmd：
                            IPC_RMID    删除信号灯
                            SETVAL      设置第semnum-th信号量的值为arg.val 

                                                设置该信号量元素的值（资源个数）
        返回值:
            成功返回0 
            失败返回-1


union semun 
{ 
    int val; /* 当 cmd 为 SETVAL 时使用 */ 
    struct semid_ds *buf; /* 当 cmd 为 IPC_STAT 或 IPC_SET 时使用 */ 
    unsigned short *array; /* 当 cmd 为 GETALL 或 SETALL 时使用 */ 
    struct seminfo *__buf; /* 当 cmd 为 IPC_INFO 时使用 */ 
};

4.对信号量完成申请和释放操作 semop

 int semop(int semid, struct sembuf *sops, size_t nsops);
        功能：
            对信号量完成申请和释放操作
        参数：
            semid:信号灯ID号
            sops:信号灯操作数组
                unsigned short sem_num;  //操作信号量的下标
                short          sem_op;   //对信号量的操作 +1(释放信号量) -1(申请信号量)
                short          sem_flg;  //SEM_UNDO 操作结束后,信号量的值会恢复到原来的值
            nsops:数组元素个数  
        返回值：
            成功返回0 
            失败返回-1
#include "../head.h"

/* 对信号量初始化 */
int init_sem(int semid, int *parray, int len)
{
    int i = 0;
    union semun myun;
    int ret = 0;

    for (i = 0; i < len; i++)
    {   
        myun.val = parray[i];
        ret = semctl(semid, i, SETVAL, myun);
        if (-1 == ret)
        {
            return -1;
        }
    }

    return 0;
}

/* 信号量申请操作 */
int sem_p(int semid, int semnum)
{
    int ret = 0;
    struct sembuf mybuf;

    mybuf.sem_num = semnum;
    mybuf.sem_op = -1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if (-1 == ret)
    {
        return -1;
    }

    return 0;
}

/* 信号量释放操作 */
int sem_v(int semid, int semnum)
{
    int ret = 0;
    struct sembuf mybuf;

    mybuf.sem_num = semnum;
    mybuf.sem_op = +1;
    mybuf.sem_flg = SEM_UNDO;
    ret = semop(semid, &mybuf, 1);
    if (-1 == ret)
    {
        return -1;
    }

    return 0;
}
#include "../head.h"

int main(void)
{
    //1.创建 key 值
    key_t key;
    int semid = 0;
    int shmid = 0;
    int val[2] = {0, 1};
    char *pshmaddr = NULL;

    key = ftok("/", 'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建共享内存
    shmid = shmget(key, 4096, IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }

    //3.创建信号量数组
    semid = semget(key, 2, IPC_CREAT | 0664);
    if (-1 == semid)
    {
        perror("fail to semget");
        return -1;
    }

    //4.对信号量数组初始化
    init_sem(semid, val, 2);

    //5.映射共享内存
    pshmaddr = shmat(shmid, NULL, 0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }

    while (1)
    {
        //6.申请读资源
        sem_p(semid, 0);

        //7.读操作
        printf("内容:%s\n", pshmaddr);
        if (!strcmp(pshmaddr, ".quit"))
        {
            break;
        }

        //8.释放写资源
        sem_v(semid, 1);
    }

    shmdt(pshmaddr);
    
    shmctl(shmid, IPC_RMID, NULL);

    semctl(semid, 0, IPC_RMID);

    return 0;
}
#include "../head.h"

int main(void)
{
    //1.创建 key 值
    key_t key;
    int semid = 0;
    int shmid = 0;
    int val[2] = {0, 1};
    char *pshmaddr = NULL;

    key = ftok("/", 'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    //2.创建共享内存
    shmid = shmget(key, 4096, IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }

    //3.创建信号量数组
    semid = semget(key, 2, IPC_CREAT | 0664);
    if (-1 == semid)
    {
        perror("fail to semget");
        return -1;
    }

    //4.对信号量数组初始化
    init_sem(semid, val, 2);

    //5.映射共享内存
    pshmaddr = shmat(shmid, NULL, 0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }

    while (1)
    {
        //6.申请写资源
        sem_p(semid, 1);

        //7.写操作
        gets(pshmaddr);

        //8.释放读资源
        sem_v(semid, 0);

        if (!strcmp(pshmaddr, ".quit"))
        {
            break;
        }
    }

    shmdt(pshmaddr);

    return 0;
}

m0_61965705
关注
【Linux】进程间通信——消息队列、共享内存与信号量
weixin_46778443的博客
05-05 1396
【Linux】进程间通信
进程间通信(信号、消息队列、共享内存、信号量)
weixin_62313265的博客
07-24 610
信号(signal)是一种软件中断，是UNIX系统中最为古老的进程之间的通信机制。用于在一个或多个进程之间传递异步信号。它提供了一种处理异步事件的方法，也是进程间惟一的异步通信方式。在Linux中，根据POSIX标准扩展以后的信号机制，不仅可以用来通知某种程序发生了什么事件，还可以给进程传递数据。...
【Linux】进程通信——共享内存+消息队列+信号量
cefler的博客
02-01 1447
【Linux】进程通信——共享内存+消息队列+信号量
进程间通信 | 管道 消息队列 共享内存 信号量 信号 socket
HUAERBUSHI521的博客
06-25 679
一.为什么需要进程间通信 进程间通信:两个进程之间的数据交互(数据传输,数据共享) 进程间为什么不能直接通信?
共享内存、消息队列、信号量
qq_51216031的博客
08-17 755
一般来说，共享内存、消息队列、信号量详解这三个技术，用的不多，简单认识了即可。如果想进一步了解，可以接着AI学习。
【Linux 系统】进程间通信（共享内存、消息队列、信号量）
Elena's Blog
04-26 2120
共享内存的生命周期随 OS。共享内存不提供任何同步与互斥的操作，双方彼此独立。共享内存是进程间通信中速度最快的。相比之下，管道就很慢了，它需要写端把数据写到管道，读端再从管道读，和管道的交互至少需要两次拷贝。还不包括如果写端的数据是从 stdin 中来的，那么就要先写到用户层缓冲区。共享内存没有进行同步与互斥。为什么创建共享内存的 SIZE 要设置成 4kb 的倍数？
【Linux】system V共享内存 | 消息队列 | 信号量
joy.728的博客
02-25 2155
本篇博客主要讲解了什么是共享内存、共享内存的原理、用共享内存实现客户端和服务端的通信、什么是消息队列、消息量以及进程互斥等等。
【linux系统编程】进行间通信——共享内存+消息队列+信号量
fight_p的博客
11-18 930
这是进程间通信的第二方式，System V标准的进程间通信，包括共享内存，消息队列，信号量。本文详细讲解了三种方式的原理，接口的介绍，以及共享内存的实现，共享内存的特点，关键在于如何理解key，用来表示共享内存，消息队列，以及消息量在内核中的唯一性等等！
【Linux】System V 共享内存、消息队列、信号量
阿润菜菜的博客
04-22 1417
带你深入理解共享内存 消息队列 信号量
Linux 进程间通信 —— 消息队列与共享内存
Outside_的博客
08-24 937
Linux 进程间通信——消息队列与共享内存
嵌入式学习DAY27 --- System V 共享内存 ，POSIX 信号量 ，POSIX 消息队列_posix 共享内存 嵌入式平台
2401_84248681的博客
05-04 1019
一、System V 共享内存二、POSIX 信号量三、POSIX 消息队列（1）在多任务操作系统中，多个进程/线程会同时运行。多个任务可能为了完成同一个事情而相互协作，这样就形成了任务之间的同步关系。同样，不同任务之间为了争夺有限的系统资源(硬件或软件资源)会进入竞争状态，这样就是任务之间的互斥关系。（2）任务之间的互斥与同步关系存在的根源在于临界资源。临界资源是指在同一个时刻只允许有限个(通常只有一个)任务可以访问(读）或者修改(写)的资源。
Linux 学习笔记—进程通信之 消息队列、信号量、共享内存的概念区别联系
c+c++的博客
10-28 987
2.5 消息队列（Message queues） 消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用IPC标识符唯一地进行识别。内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。每个消息队列中的消息，又构成一个独立的链表。 消息队列克服了信号承载信息量少，管道只能承载...
Linux C 进程间的通信——共享内存、消息队列、信号量
qq_53612102的博客
09-15 1894
早期：有名管道、无名管道、信号，system V IPC：共享内存、消息队列、信号量。除了这六种以外呢其实还有另一种进程间的通信——域通信，不过域通信就要结合TCP或者UDP来操作，基本和管道差不多，这部分有缘再更。
Linux —— 网络基础（一）
学习C++的小陈同学
09-22 1000
本篇只是简单的建立一个关于网络的基本概念和框架，有很多概念上不太完整，只是自己为了自己在初入学习网络时的简单粗俗理解，方便后续深入的学习网络相关的知识，如果有需要纠错的地方，可以评论一起讨论。
【Linux实践】实验四：Shell实用功能及文件权限
Fulling的博客
09-25 708
实验内容 1、使用命令“cat /etc/named.conf”设置为别名named，然后再取消别名。 2、使用echo命令和输出重定向创建文本文件/root/nn，内容是hello，然后再使用追加重定向输入内容为word。 3、使用管道方式分页显示/etc/passwd的内容。 4、分别用文字设定法和数字设定法，对/root/ab文件设置权限，所有者为读取、写入和执行权限，同组用户为读取和写入权限，其他用户没有任何权限。 5、将文件/root/ab所有者更改为用户zhangsan。 6、将目录/root/
Linux 安装redis主从模式+哨兵模式3台节点
一千个读者就有一千个哈姆雷特
09-27 179
Linux 安装redis主从模式+哨兵模式3台节点
linux 源代码编译
Lxn2zh的博客
09-27 1097
有时候会在linux上下载源码包，然后进行编译成可执行的文件，这个过程需要经过configure、make、make install、make clean四个步骤。configure 为这个程序在当前的操作系统环境下选择合适的编译器和环境参数来编译该代码。make install 将已编译好的可执行文件安装到操作系统指定或默认的安装目录下。make 对程序代码进行编译操作，会将源码编译成可执行的目标文件。make clean 删除编译时临时产生的目录或文件。
在新ARM板上移植U-Boot和Linux指南
最新发布
qq_37255138的博客
09-27 829
基于i.MX6的模块，带有扩展板，以太网，I2C，SPI，NAND，eMMC，SD卡读卡器，USB设备，EEPROM，GPIO，UART，音频（I2S），HDMI，LVDS，PCIe，USB主机，RTC，电源管理集成电路（PMIC）
Linux ping c实现
xuyun0565的专栏
09-24 363
linux下ping程序的c实现。
Linux系统VIPC：信号量、共享内存和消息队列解析
"该Linux课件主要讲解了System V进程间通信（IPC）中的三种机制：信号量、共享内存和消息队列。这些机制在多线程和多进程环境中用于协调进程间的通信和资源共享。课件中详细介绍了每种机制的基本概念、使用方法以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值