学习记录——day27 进程间通信 IPC通信机制 消息队列 共享内存

已于 2024-08-07 09:09:20 修改
阅读量913 收藏 20
点赞数 13
文章标签： 学习
于 2024-08-06 20:15:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64918301/article/details/140945433
版权

目录

一、IPC通信机制

1、system V提供了三种IPC（interprocess communication）进程间通信方式 消息队列 共享内存 信号量集

2、该通信机制是独立于进程而存在的:当进程将数据写入该通信对象中后，即使进程已经结束，对象中保存的内容仍然存在

3、IPC对象相关指令   ipcs  ipcrm

二、消息队列

1、消息队列的特点

2、消息队列的相关API函数接口 ftok msgget msgsnd msgrcv msgctl

 3、发送端实现

4、接收端实现

5、 获取消息队列的属性

三、共享内存

1、特点

2、共享内存的PAI函数接口  shmget  shmat shmdt

 3、发送端实现

4、接收端实现

使用消息队列完成两个进程之间相互通信

00snd.c

00rcv.c

 

一、IPC通信机制

1、system V提供了三种IPC（interprocess communication）进程间通信方式 消息队列 共享内存 信号量集

消息队列：本质上是在内核空间维护的一个队列，发送者可以将消息先放入到该队列上，接收者根据自己的需求读取队列上的信息
共享内存：在进程外申请一个物理内存，不同进程可以通过内存映射的方式共同使用这段内存，类似于多线程中的临界资源，同样存在竟态，通过使用信号量解决
信号量集：将多个无名信号量，放入一个集合中，分别控制不同的进程，用于进程间同步问题

2、该通信机制是独立于进程而存在的:当进程将数据写入该通信对象中后，即使进程已经结束，对象中保存的内容仍然存在

3、IPC对象相关指令   ipcs  ipcrm

1）ipcs                              查看当前所有的ipc对象的信息
2）ipcs -q                          查看消息队列的信息
3）ipcs -m                         查看共享内存的信息
4）ipcs -s                          查看信号量集的信息
5）ipcrm -q\-m\-s   ID号    删除指定的ipc对象

二、消息队列

1、消息队列的特点

1）放入消息队列中的消息需要进行封装，包括消息类型和消息数据

2）消息队列的消息遵循先进先出原则，如果取出时不指定类型，则默认取第一个，如果指定了类型，则取该类型第一个放入队列中的消息

3）消息队列相关API函数接口

4）消息队列的大小为 16k

2、消息队列的相关API函数接口 ftok msgget msgsnd msgrcv msgctl

1）创建用于生成消息队列的钥匙
       #include <sys/types.h>
       #include <sys/ipc.h>

       key_t ftok(const char *pathname, int proj_id);
        功能：通过给定的文件路径和一个随机ID值创建出一个用于IPC通信的key值       ftok("/", 'k');
        参数1：文件路径，该文件的inode号占key值的2字节，该文件的设备号占key值的1字节
        参数2：一个给定的随机值，该值占key值的1字节
        返回值：成功返回创建出的key值，失败返回-1并置位错误码

2）通过钥匙创建出一个消息队列对象
       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>

       int msgget(key_t key, int msgflg);
        功能：通过给定的key值创建一个消息队列
        参数1：用于创建消息队列的key值，该值可以由ftok创建出来，也可以是 IPC_PRIVATE,表示进行亲缘进程间的通信
        参数2：创建标识位
                IPC_CREAT：表示本次操作要创建一个消息队列，如果该key值对应的消息队列已经存在，则直接打开该消息对象
                IPC_EXCL:表示本次确保要创建一个新的消息队列，如果该消息队列已经存在，则该函数报错，错误码为EEXIST
                创建文件的权限，也在该参数中，使用位或连接
        返回值：成功返回消息队列的id号，失败返回-1并置位错误码

3）向消息队列中存放消息
       int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
       功能：向消息队列中存放消息，要求当前进程对消息队列具有可写权限
       参数1：消息队列的id号
       参数2：是指向封装好的消息的起始地址，通常类型如下，但是需要用户自己定义
          struct msgbuf {
               long mtype;       /* message type, must be > 0 */
               char mtext[1];    /* message data */
           };
        参数3：表示参数2中，消息正文的大小，不包含消息类型的大小
        参数4：发送标识位，表示是否阻塞
            0：表示阻塞
            IPC_NOWAIT：表示非阻塞
        返回值：成功返回0，失败返回-1并置位错误码

4）从消息队列中取消息
        size_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
        功能：从消息队列中取消息
        参数1：消息队列的id号
        参数2：存放消息的容器起始地址
        参数3：消息正文的大小
        参数4：取出消息的类型
                >0: 表示取出该类型的消息的第一个消息
                =0：不限制类型，直接取消息队列中的第一个
                <0: 取出消息队列中类型小于msgtyp绝对值的第一个
                    例如：  50   10   2   10    6   6  8
                    -7:    2  6  6 ---> 2
        参数5：是否阻塞
            0：表示阻塞
            IPC_NOWAIT：表示非阻塞
        返回值：成功返回成功读取的字节个数，失败返回-1并置位错误码

5）控制消息队列
       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>

       int msgctl(int msqid, int cmd, struct msqid_ds *buf);
       功能：完成对消息队列指定的cmd操作
       参数1：消息队列的id号
       参数2：操作指令
          IPC_STAT：获取消息队列的属性，此时参数3必须要给定，表示接收消息队列的属性
             struct msqid_ds {
               struct ipc_perm msg_perm;     /* 拥有者和权限 */
               time_t          msg_stime;    /* 最新一次向消息队列中发送数据的时间 */
               time_t          msg_rtime;    /* 最新一次消息队列接受数据的时间 */
               time_t          msg_ctime;    /* 最新一次操作消息队列的时间 */
               unsigned long   __msg_cbytes; /* 当前队列中已用的字节数 */
               msgqnum_t       msg_qnum;     /* 当前队列中消息的个数*/
               msglen_t        msg_qbytes;   /* 队列的最大容量，默认是16K */
               pid_t           msg_lspid;    /* 最后一次向消息队列中发送消息的进程id号 */
               pid_t           msg_lrpid;    /* 最后一次从消息队列中取消息的进程id号 */
           };
               对第一个成员的介绍
              struct ipc_perm {
               key_t          __key;       /* 键值 */
               uid_t          uid;         /* 当前拥有者的用户id号 */
               gid_t          gid;         /*当前拥有者的组id号 */
               uid_t          cuid;        /* 创建消息队列的进程的用户id */
               gid_t          cgid;        /* 创建消息队列进程的组id号 */
               unsigned short mode;        /* 操作权限 */
               unsigned short __seq;       /* 队列号 */
           };
         IPC_SET：设置消息队列的属性  
         IPC_RMID：删除消息队列，当参数2位该值时，参数3可以忽略，直接填NULL即可
         返回值：成功返回0，失败返回-1并置位错误码

 3、发送端实现

#include<myhead.h>
//要发送的消息类型
struct msgbuf 
{
    long mtype;       /* message type, must be > 0 */
    char mtext[1024];    /* message data */
};
#define SIZE sizeof(struct msgbuf)-sizeof(long)


int main(int argc, const char *argv[])
{
    //1、创建key值，用于生产消息队列
    key_t key = ftok("/", 'k');
    if(key == -1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key = %#x\n", key);

    //2、通过key值创建一个消息队列
    int msqid = msgget(key, IPC_CREAT|0664);
    if(msqid == -1)
    {
        perror("msgget error");
        return -1;
    }
    printf("msqid = %d\n", msqid);        //id号

    //向消息队列中存放消息
    struct msgbuf buf;
    
    while(1)
    {
        printf("请输入消息类型：");
        scanf("%ld", &buf.mtype);
        getchar();                    //吸收回车
        printf("请输入消息正文：");
        fgets(buf.mtext, SIZE, stdin);        //从终端获取数据
        buf.mtext[strlen(buf.mtext)-1] = 0;   //将换行换成 '\0'

        //将消息发送到消息队列中
        msgsnd(msqid, &buf, SIZE, 0);
        //参数1：消息队列id号
        //参数2：消息的起始地址
        //参数3：消息正文大小
        //参数4：阻塞形式发送数据
        printf("发送成功\n");

        if(strcmp(buf.mtext, "quit") == 0)
        {
            break;
        }
    }

    return 0;
}

4、接收端实现

#include<myhead.h>
//要发送的消息类型
struct msgbuf 
{
    long mtype;       /* message type, must be > 0 */
    char mtext[1024];    /* message data */
};
#define SIZE sizeof(struct msgbuf)-sizeof(long)


int main(int argc, const char *argv[])
{
    //1、创建key值，用于生产消息队列
    key_t key = ftok("/", 'k');
    if(key == -1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key = %#x\n", key);

    //2、通过key值创建一个消息队列
    int msqid = msgget(key, IPC_CREAT|0664);
    if(msqid == -1)
    {
        perror("msgget error");
        return -1;
    }
    printf("msqid = %d\n", msqid);        //id号

    //从消息队列中读取消息
    struct msgbuf buf;
    
    while(1)
    {
        msgrcv(msqid, &buf, SIZE, 0, 0);
        //参数1：消息队列id号
        //参数2：数据容器起始地址
        //参数3：数据的正文大小
        //参数4：消息类型，0表示任意类型
        //参数5：表示阻塞读取消息

        printf("收到消息为：%s\n", buf.mtext);
    }

    return 0;
}

5、 获取消息队列的属性

#include<myhead.h>


int main(int argc, const char *argv[])
{
    //1、创建key值，用于生产消息队列
    key_t key = ftok("/", 'k');
    if(key == -1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key = %#x\n", key);

    //2、通过key值创建一个消息队列
    int msqid = msgget(key, IPC_CREAT|0664);
    if(msqid == -1)
    {
        perror("msgget error");
        return -1;
    }
    printf("msqid = %d\n", msqid);        //id号

    //获取该消息队列的属性
    struct msqid_ds ds;          //用于存放消息队列属性的变量
    if(msgctl(msqid, IPC_STAT, &ds) == -1)
    {
        perror("msgctl error");
        return -1;
    }

    //程序执行至此，该消息队列中的相关信息就被存入到ds结构体中了
    printf("键：%#x, msqid:%d, 权限：%#o, 已用字节：%ld, 消息：%ld\n", \
            ds.msg_perm.__key, msqid, ds.msg_perm.mode, ds.__msg_cbytes,\
            ds.msg_qnum);



    return 0;
}

三、共享内存

1、特点

1）共享内存是多个进程共享一个外部的物理内存，直接访问内存获取数据，避免了数据的传输，使得效率较高

2）共享内存具有时效性，存放到共享内存区域中的数据，如果不及时读取，下一次写入后，前面的数据会被覆盖

3）共享内存的操作不是一次性的，写入到共享内存中的数据，即使读取出去后，依然存在于共享内存，直到下一次写入

2、共享内存的PAI函数接口  shmget  shmat shmdt

1）创建共享内存对象
         #include <sys/ipc.h>
       #include <sys/shm.h>

       int shmget(key_t key, size_t size, int shmflg);
       功能：通过给定的key值创建一个共享内存的对象，并返回该对象的id
       参数1：key值，可以是IPC_PRIVATE也可以是由ftok创建出来的
       参数2：申请的共享内存段的大小，必须是PAGE_SIZE的整数倍，如果超过，则向上取整
       参数3：创建的标识
                IPC_CREAT：表示本次操作要创建一个共享内存，如果该key值对应的共享内存已经存在，则直接打开该共享内存对象
                IPC_EXCL:表示本次确保要创建一个新的共享内存，如果该共享内存已经存在，则该函数报错，错误码为EEXIST
                创建文件的权限，也在该参数中，使用位或连接
        返回值：成功返回创建出来的共享内存的id，失败返回-1并置位错误码
 
2）将共享内存地址映射到用户空间
       void *shmat(int shmid, const void *shmaddr, int shmflg);
       功能：映射共享内存的地址到用户空间
       参数1：共享内存ID
       参数2：对齐页地址，一般填NULL，让系统选择合适的对齐页
       参数3：共享内存的权限
           SHM_RDONLY：只读权限
           0：    读写权限
       返回值：  成功返回映射的共享内存段的地址，失败返回（void *）-1并置位错误码          
       
 3）取消共享内存的映射
             int shmdt(const void *shmaddr);
             功能：取消共享内存的映射
             参数：共享内存映射的地址
             返回值：成功返回0，失败返回-1并置位错误码
                 
 4）共享内存的控制函数
        #include <sys/ipc.h>
       #include <sys/shm.h>

       int shmctl(int shmid, int cmd, struct shmid_ds *buf);
       功能：控制共享内存对象
       参数1：共享内存的id号
       参数2：操作指令
          IPC_STAT：获取共享内存的属性，此时参数3必须要给定，表示接收共享内存的属性
         IPC_SET：设置共享内存的属性  
         IPC_RMID：删除共享内存，当参数2位该值时，参数3可以忽略，直接填NULL即可
        返回值： 成功返回0，失败返回-1并置位错误码      

 3、发送端实现

#include<myhead.h>
#include<sys/user.h>

int main(int argc, const char *argv[])
{
    //1、创建key值用于创建共享内存段
    key_t key = ftok("/", 't');
    if(key == -1)
    {
        perror("ftok error");
        return -1;
    }

    printf("key = %d\n", key);

    //2、创建一个共享内存的对象
    int shmid = shmget(key, PAGE_SIZE, IPC_CREAT|0664);
    if(shmid == -1)
    {
        perror("shmget error");
        return -1;
    }
    printf("shmid = %d\n", shmid);

    //3、将共享内存段映射到程序中来
    char *addr = (char *)shmat(shmid, NULL, 0);
    //参数1：共享内存的id号
    //参数2：系统自动映射对齐页
    //参数3：表示对共享内存的操作权限为读写权限
    printf("addr = %p\n", addr);         //输出映射的地址

    //向共享内存中写入数据
    strcpy(addr, "hello a hua qing yuan jian\n");

    sleep(5);

    //取消映射关系
    if(shmdt(addr) ==-1)
    {
        perror("shmdt error");
        return -1;
    }


    while(1);

    return 0;
}

4、接收端实现

#include<myhead.h>
#include<sys/user.h>

int main(int argc, const char *argv[])
{
    //1、创建key值用于创建共享内存段
    key_t key = ftok("/", 't');
    if(key == -1)
    {
        perror("ftok error");
        return -1;
    }

    printf("key = %d\n", key);

    //2、创建一个共享内存的对象
    int shmid = shmget(key, PAGE_SIZE, IPC_CREAT|0664);
    if(shmid == -1)
    {
        perror("shmget error");
        return -1;
    }
    printf("shmid = %d\n", shmid);

    //3、将共享内存段映射到程序中来
    char *addr = (char *)shmat(shmid, NULL, 0);
    //参数1：共享内存的id号
    //参数2：系统自动映射对齐页
    //参数3：表示对共享内存的操作权限为读写权限
    printf("addr = %p\n", addr);         //输出映射的地址

    //读出共享内存中的数据
    printf("消息为：%s", addr);

    sleep(5);
    if(shmdt(addr) == -1)
    {
        perror("shmdt error");
        return -1;
    }

    //删除共享内存
    if(shmctl(shmid, IPC_RMID, NULL) == -1)
    {
        perror("shmctl error");
        return -1;
    }


    while(1);

    return 0;
}

使用消息队列完成两个进程之间相互通信

00snd.c

#include <myhead.h>

// 要发送的信息类型
struct msgbuf
{
    long mtype;
    char mtext[1024];
};

#define SIZE sizeof(struct msgbuf) - sizeof(long)

int main(int argc, char const *argv[])
{
    // 1、创建key值用于生成消息队列
    key_t key = ftok("/", 'k');
    if (key == -1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key = %#x\n", key);

    // 2、通过key值创建一个消息队列
    int msqid = msgget(key, IPC_CREAT | 0664);
    if (msqid == -1)
    {
        perror("msgget error");
        return -1;
    }
    printf("msqid = %d\n", msqid);

    // 3、创建父子进程
    pid_t pid;
    if ((pid = fork()) == -1)
    {
        perror("fork error");
        return -1;
    }
    else if (pid == 0)
    {
        // 子进程
        // 4、从消息队列接收信息
        struct msgbuf buf;
        while (1)
        {
            msgrcv(msqid, &buf, SIZE, 2, 0);
            printf("进程1子程序收到信息:%s\n", buf.mtext);

            if (strcmp(buf.mtext, "quit") == 0)
            {
                break;
            }
        }

        exit(EXIT_SUCCESS);
    }

    // 父进程
    //  3、向消息队列中输入数据
    struct msgbuf buf;
    buf.mtype = 1;
    while (1)
    {
        printf("进程1父程序输入信息:");
        fgets(buf.mtext, SIZE, stdin);
        buf.mtext[strlen(buf.mtext) - 1] = 0;

        // 将信息发送到消息队列中
        msgsnd(msqid, &buf, SIZE, 0);
        printf("发送结束\n");

        if (strcmp(buf.mtext, "quit") == 0)
        {
            break;
        }
    }
    //回收子程序资源
    wait(NULL);
    // 删除消息队列
    if (msgctl(msqid, IPC_RMID, NULL) == -1)
    {
        perror("msgctl error");
        return -1;
    }

    return 0;
}

00rcv.c

#include <myhead.h>

// 要发送的信息类型
struct msgbuf
{
    long mtype;
    char mtext[1024];
};

#define SIZE sizeof(struct msgbuf) - sizeof(long)

int main(int argc, char const *argv[])
{
    // 1、创建key值用于生成消息队列
    key_t key = ftok("/", 'k');
    if (key == -1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key = %#x\n", key);

    // 2、通过key值创建一个消息队列
    int msqid = msgget(key, IPC_CREAT | 0664);
    if (msqid == -1)
    {
        perror("msgget error");
        return -1;
    }
    printf("msqid = %d\n", msqid);

    // 3、创建父子进程
    pid_t pid;
    if ((pid = fork()) == -1)
    {
        perror("fork error");
        return -1;
    }
    else if (pid == 0)
    {
        // 子进程
        // 4、向消息队列中输入数据
        struct msgbuf buf;
        buf.mtype = 2;
        while (1)
        {
            printf("进程2子程序输入信息:");
            fgets(buf.mtext, SIZE, stdin);
            buf.mtext[strlen(buf.mtext) - 1] = 0;

            // 将信息发送到消息队列中
            msgsnd(msqid, &buf, SIZE, 0);
            printf("发送结束\n");

            if (strcmp(buf.mtext, "quit") == 0)
            {
                break;
            }
        }
        exit(EXIT_SUCCESS);
    }

    // 父进程
    // 4、从消息队列读取信息
    struct msgbuf buf;
    while (1)
    {
        msgrcv(msqid, &buf, SIZE, 1, 0);
        printf("进程2父程序收到信息:%s\n", buf.mtext);

        if (strcmp(buf.mtext, "quit") == 0)
        {
            break;
        }
    }

    // 回收子程序资源
    wait(NULL);
    // 删除消息队列
    if (msgctl(msqid, IPC_RMID, NULL) == -1)
    {
        perror("msgctl error");
        return -1;
    }
    return 0;
}

子座
关注
进程间通讯（IPC）（有信号捕捉函数）
weixin_41723504的博客
08-08 626
  1、IPC（Internal Processes Communication） 进程间通讯---&gt;实际上数据的交换。   通过全局变量的方式实现不了进程间通讯 因为进程内存空间，都是相互独立的，不能通过这种方式去互相访问。   进程间通讯的方式： 1、内存映射，内存共享。 2、通过读写文件的方式。这种效率比较低。 3、信号。 4、消息队列。 5、信号量。 6、...
Android之IPC4————Bander1 概述与Bander驱动
冰炭不投day的博客
11-07 805
Android之IPC4————Bander 1概述 文章目录Android之IPC4————Bander 1概述一.概述二.储备知识1.进程空间的划分2.进程隔离和跨进程通信3.Android的框架三.Binder概述1.Binder是什么2.Binder的优势3.Binder原理4. C/S模式四.Binder驱动1.概述2.系统调用3.binder_open3. binder_mmap4.b...
IPC之消息队列与共享内存
weixin_62603444的博客
04-15 1518
•共享内存是由IPC为一个进程创建的一个特殊的地址范围，它将出现在进程的地址空间中。•其他进程可以把同一段共享内存段连接到它们自己的地址空间里去。•所有进程都可以访问共享内存地址，就好像它们是有malloc分配的一样•如果一个进程向这段共享内存写了数据，所做的改动会立刻被有权访问同一段共享内存的其他进程看到共享内存函数：shmget函数：函数原型：int shmget(key_t key,size_t size, int shmflg);作用：用来创建共享内存•。
Linux IPC机制 - 函数总结
weixin_33989780的博客
10-27 123
以下表格为IPC的函数总结，IPC包括： 1. 无名管道（Pipe）：http://www.cnblogs.com/Jimmy1988/p/7553069.html 2.有名管道（FIFO）：http://www.cnblogs.com/Jimmy1988/p/7553069.html 3.消息队列（Message Queue）：http://www.cnblogs.com/Jimmy198...
ftok说明
aiwoziji13的专栏
07-08 9063
文章一：ftok函数　　系统建立IPC通讯（消息队列、信号量和共享内存）时必须指定一个ID值。通常情况下，该id值通过ftok函数得到。 ftok原型　　头文件： 　　#include 　　#include 　　如下： 　　key_t ftok( char * fname,
IPC函数总结
lfxyan的专栏
06-27 1269
shm_open(const char* name, int oflag, mode_t mode);创建或打开一个共享内存区对象。 int ftruncate(int fd, off_t length);修改共享内存区对象的大小。 int fstat(int fd, struct stat* buf);获取共享内存区对象的信息。 void* mmap(void* addr, size_t
c函数之【进程通信(IPC)函数】
archerLea
03-30 381
点击打开链接 ftok   (将文件路径和计划代号转为SystemcVIPCkey) msgctl (控制信息队列的运作) msgget (建立信息队列) msgrcv (从信息队列读取信息) msgsnd (将信息送入信息队列) semctl (控制信号队列的操作) semget (配置信号队列) semop  (信号处理) shmat  (attach共享内存) shmct
Android学习笔记：Android基础知识点（不断更新中）
浩比的专栏
10-28 2万+
1、Android系统的四大组件分别是：活动（Activity）、服务（Service）、广播接收器（Broadcast Receiver）、内容提供器（Content Provider）。 2、定义一个应用程序名的字符串，有以下两种方式来引用它：
ym——Andorid-15k+的面试题。
热门推荐
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
python开发之线程与进程
冠军阿狗的博客
03-31 1011
python开发之线程与进程一、线程与进程1. 线程（thread）2. 进程（process）3. 进程与线程的区别4. Python GIL(Global Interpreter Lock 全局解释器锁)二、threading模块1. 线程的两种调用方式2. Join & Daemon三、锁1. 同步锁(Lock)同步锁与GIL的关系？2. 线程死锁和递归锁3. 条件变量(Condit...
IPC(进程间通信)相关常用函数
DKLost的博客
10-23 212
IPC进程间通信（消息队列，共享内存，信号量）常用函数
IPC-消息队列
草根学僧
06-09 720
什么是消息队列？ 消息队列是消息的链接表，储存在内核中，由消息队列标识符标识。每个数据块都被认为有一个类型。接受者进程接收的数据块可以有不同的类型值。 消息队列的特点 消息队列不同于管道，消息队列是基于数据块的，而管道是基于字节流的，并且消息队列读取不一定要先入先出，可以根据数据类型读取。还有就是因为管道是随进程的，进程结束管道生命周期也就结束，而对于消息队列来说，是随内核的，就算进程退出，不去
IPC消息队列 -- （Linux系统编程）
weixin_54355176的博客
07-21 222
|# 1. 消息队列 背景 管道和套接字比较适合两三个进程之间的通信，如果进程成倍增加，管道和套接字的数量也会阶乘级的增加，管理也非常复杂麻烦。于是出现的消息队列 比喻 回转寿司 优先级 让列宁同志先走 本质 内核链表 2. POSIX消息列表 2.1 查看 POSIX消息队列预览：man mq_overview 查看POSIX消息队列：ls /dev/mqueue cat /dev/mqueue/PIC名字 2.2 接口 头文件：mqueue.h 库：librt.so(real t
进程间通信（IPC）之 消息队列
d0203的博客
03-20 278
type < 0, 返回队列中消息类型值小于或等于type 绝对值的消息，如果有多个，则取类型值最小的消息。消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志位。消息队列，是消息的链表，存放在内核中。消息队列是面向记录的，其中的消息具有特点的格式以及特点的优先级。type > 0, 返回队列中消息类型为type的第一个消息。type = 0, 返回队列中的第一个消息。
IPC的七种方式
weixin_44280688的博客
11-29 1242
文章目录pipeFIFOmessage queuesemaphoreshared memeory共享内存+信号量+消息队列 例子signalsocket 实例 概念: 同步: 一个进程将数据写入, 然后就去睡眠等待, 直到读取进程将数据取走, 在去唤醒; 读进程与之类似 互斥: 一个进程对pipe进行I/O操作时,其他进程必须等待 pipe feature: 容量有限,只用于父子进程通信...
IPC对象；消息队列；共享内存；信号灯
最新发布
qq_56797509的博客
08-14 499
/SEM_UNDO 操作结束后,信号量的值会恢复到原来的值。//对信号量的操作 +1(释放信号量) -1(申请信号量)read.c 创建共享内存 -> 映射 -> 从共享内存中读取数据 -> 显示到终端。write.c 创建共享内存 -> 映射 -> 从终端接收数据写入共享内存中。recv.c 创建消息队列 -> 接收消息 -> 销毁消息队列。ipcrm -q/m/s 消息队列ID/共享内存ID/信号灯ID。IPC_CREAT：创建一个信号量数组。IPC_CREAT：创建一个消息队列。
Linux应用开发（7）：Linux进程间通信（IPC）：POSIX消息队列
tecsai的博客
04-17 1085
消息队列是Linux提供进程间通信的一种方式。当多个进程需要共享或交换数据时，就会用到消息队列。此外，消息队列还可以作为一个缓冲区，可以在处理速度不同的进程间提供数据交换。
Linux下进程间通信的手段及IPC函数命令
Y0uX1Nr3N的博客
04-08 418
Linux下进程间通信的几种手段简介：1.管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；2.信 号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了 支持Unix早期信...
Python学习：Json与Csv数据存储实战——爬虫Day12
在本篇关于爬虫学习的文章中，主要关注的是数据存储技术中的JSON和CSV格式，以及如何在Python中处理这两种常见的数据交换格式。文章从JSON的定义和特点开始讲解，指出JSON是一种轻量级的数据交换格式，相较于XML，其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值