linux 进程间通信 消息队列

最新推荐文章于 2020-08-20 08:36:25 发布
最新推荐文章于 2020-08-20 08:36:25 发布
阅读量754 收藏
点赞数 1
分类专栏： linux系统编程 文章标签： linux 消息队列 进程间通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014338577/article/details/47704039
版权

消息队列常用操作函数如下：

    #include <sys/msg.h>  
    #include <sys/types.h>  
    #include <sys/ipc.h>  
      
    key_t ftok(const char *pathname, int proj_id);  
    int msgget(key_t key, int msgflg);  
    int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);  
    int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);  
    int msgctl(int msqid, int cmd, struct msqid_ds *buf);

IPC对象数据结构：
内核为每个IPC对象维护一个数据结构 
struct ipc_perm {
    key_t          __key;       /* Key supplied to xxxget(2) */
    uid_t          uid;         /* Effective UID of owner */
    gid_t          gid;         /* Effective GID of owner */
    uid_t          cuid;        /* Effective UID of creator */
    gid_t          cgid;        /* Effective GID of creator */
    unsigned short mode;        /* Permissions */
    unsigned short __seq;       /* Sequence number */
};

struct msqid_ds {
    struct ipc_perm msg_perm;     /* Ownership and permissions */
    time_t         msg_stime;    /* Time of last msgsnd(2) */
     time_t         msg_rtime;    /* Time of last msgrcv(2) */
    time_t         msg_ctime;    /* Time of last change */
    unsigned long    __msg_cbytes; /* Current number of bytes in
                        queue (nonstandard) */
    msgqnum_t         msg_qnum;     /* Current number of messages
                                                            in queue */
    msglen_t         msg_qbytes;   /* Maximum number of bytes
                                                allowed in queue */
    pid_t                      msg_lspid;      /* PID of last msgsnd(2) */
    pid_t                  msg_lrpid;      /* PID of last msgrcv(2) */
};


msgget函数 
功能：用来创建和访问一个消息队列
原型
int msgget(key_t key, int msgflg);
参数
key: 某个消息队列的名字
msgflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的
返回值：成功返回一个非负整数，即该消息队列的标识码；失败返回-1


msgget函数参数关系图：



msgctl函数
功能：消息队列的控制函数
原型
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
参数
msqid: 由msgget函数返回的消息队列标识码
cmd:是将要采取的动作,（有三个可取值）
返回值：成功返回0，失败返回-1


msgsnd函数
功能：把一条消息添加到消息队列中
原型
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
参数
msgid: 由msgget函数返回的消息队列标识码
msgp:是一个指针，指针指向准备发送的消息，
msgsz:是msgp指向的消息长度，这个长度不含保存消息类型的那个long int长整型
msgflg:控制着当前消息队列满或到达系统上限时将要发生的事情
返回值：成功返回0；失败返回-1
msgflg=IPC_NOWAIT表示队列满不等待，返回EAGAIN错误。
消息结构在两方面受到制约。首先，它必须小于系统规定的上限值；其次，它必须以一个long int长整数开始，接收者函数将利用这个长整数确定消息的类型
消息结构参考形式如下：
struct msgbuf 

{
long  mtype;
char mtext[100];
}



msgrcv函数
功能：是从一个消息队列接收消息
原型
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
参数
msgid: 由msgget函数返回的消息队列标识码
msgp:是一个指针，指针指向准备接收的消息，
msgsz:是msgp指向的消息长度，这个长度不含保存消息类型的那个long int长整型
msgtype:它可以实现接收优先级的简单形式
msgflg:控制着队列中没有相应类型的消息可供接收时将要发生的事
返回值：成功返回实际放到接收缓冲区里去的字符个数，失败返回-1
msgtype=0返回队列第一条信息
msgtype>0返回队列第一条类型等于msgtype的消息　
msgtype<0返回队列第一条类型小于等于msgtype绝对值的消息，并且是满足条件的消息类型最小的消息


msgflg=IPC_NOWAIT，队列没有可读消息不等待，返回ENOMSG错误。
msgflg=MSG_NOERROR，消息大小超过msgsz时被截断 
msgtype>0且msgflg=MSG_EXCEPT，接收类型不等于msgtype的第一条消息。

msg01.c 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdio.h>

int main(int argc, char *argv[])
{

        int msg_id = msgget( 0x1234, 0666);
        if(msg_id == -1)
        {
                printf("msgget error\n");
                return -1;
        }


        return 0;
}



msg02.c 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdio.h>
#include <errno.h>
int main(int argc, char *argv[])
{

        int msg_id = msgget( 0x1234, 0666);
        if(msg_id == -1)
        {
                printf("msgget error\n");
                if(errno == ENOENT )
                {
                        printf("No message queue exists for key\n");
                        return -1;
                }
        }


        return 0;
}

msg03.c 

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdio.h>
#include <errno.h>
int main(int argc, char *argv[])
{

        int msg_id = msgget( 0x1234, IPC_CREAT | 0666);
        if(msg_id == -1)
        {
                printf("msgget error\n");
                if(errno == ENOENT )
                {
                        printf("No message queue exists for key\n");
                        return -1;
                }
        }

        printf("get msg queue id = %d\n", msg_id);

        struct msqid_ds mq;
        if(msgctl(msg_id, IPC_STAT, &mq) != 0)
        {
                //printf("msgctl error\n");
                perror("msgctl error:\n");
                return -1;
        }

        int mode = mq.msg_perm.mode;
        int curretSize = mq.__msg_cbytes;
        int currentNumber = mq.msg_qnum;
        printf("mode = %o, curretSize = %d, currentNumber = %d\n", mode, curretSize, currentNumber);

        mq.msg_perm.mode = 0644;
        if(msgctl(msg_id, IPC_SET, &mq) != 0)
        {
                perror("msgget err");
                return -1;
        }


        return 0;
}

msg04.c 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdio.h>
#include <errno.h>
int main(int argc, char *argv[])
{

        int msg_id = msgget( 0x1234, IPC_CREAT | 0666);
        if(msg_id == -1)
        {
                printf("msgget error\n");
                if(errno == ENOENT )
                {
                        printf("No message queue exists for key\n");
                        return -1;
                }
        }

        printf("get msg queue id = %d\n", msg_id);

        struct msqid_ds mq;
        if(msgctl(msg_id, IPC_STAT, &mq) != 0)
        {
                //printf("msgctl error\n");
                perror("msgctl error:");
                return -1;
        }

        int mode = mq.msg_perm.mode;
        int curretSize = mq.__msg_cbytes;
        int currentNumber = mq.msg_qnum;
        printf("mode = %o, curretSize = %d, currentNumber = %d\n", mode, curretSize, currentNumber);

        if(msgctl(msg_id, IPC_RMID, NULL) != 0)
        {
                perror("msgctl error:");
                return -1;
        }

        return 0;
}


消息队列的简单应用：

消息队列实现回射客户/服务器




echoclient.c 
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)

#define MSGMAX 8192
struct msgbuf {
	long mtype;       /* message type, must be > 0 */
	char mtext[MSGMAX];    /* message data */
};

//思路：
//客户端发给服务器消息类型总是1
//服务器端回给客户端的type是对方进程号
//相当于服务器端 从消息队列中收消息，然后服务器端分类型回复客户端（通过消息队列）


//n个进程通过消息队列进行交换
//有没有产生死锁的可能
//n个客户端向服务器发送消息（本质上是向内核消息队列发送消息），若消息队列满了；服务区回射时，会阻塞。。造成程序死锁
//即使，非阻塞。。。仍然回阻塞。。

void echo_cli(int msgid)
{
	int n;
	int pid;
	pid = getpid();
	struct msgbuf msg;
	memset(&msg, 0, sizeof(msg));
	
	//消息内容由：自己的pid+键盘输入
	*((int*)msg.mtext) = pid;
	//消息类型 1
	msg.mtype = 1;
	
	while (fgets(msg.mtext+4, MSGMAX, stdin) != NULL)
	{
		if (msgsnd(msgid, &msg, 4+strlen(msg.mtext+4), 0) < 0)
			ERR_EXIT("msgsnd");

		//前四个字节是自己的pid
		memset(msg.mtext+4, 0, MSGMAX - 4);
		if ((n = msgrcv(msgid, &msg, MSGMAX, pid, 0)) < 0)
                        ERR_EXIT("msgsnd");

		fputs(msg.mtext+4, stdout);
		memset(msg.mtext+4, 0, MSGMAX-4);
	}
}

int main(int argc, char *argv[])
{
	int msgid;
	msgid = msgget(0x1234, 0);
	if (msgid == -1)
		ERR_EXIT("msgget");

	echo_cli(msgid);
	return 0;
}

echoserver.c 
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) \
        do \
        { \
                perror(m); \
                exit(EXIT_FAILURE); \
        } while(0)


#define MSGMAX 8192
struct msgbuf {
	long mtype;       /* message type, must be > 0 */
	char mtext[MSGMAX];    /* message data */
};


void echo_srv(int msgid)
{
	int n;
	struct msgbuf msg;
	memset(&msg, 0, sizeof(msg));
	while (1)
	{
		if ((n = msgrcv(msgid, &msg, MSGMAX, 1, 0)) < 0)
			ERR_EXIT("msgsnd");
		
		int pid;
		pid = *((int*)msg.mtext);

		fputs(msg.mtext+4, stdout);
		msg.mtype = pid;
		msgsnd(msgid, &msg, n, 0);
	}
}

int main(int argc, char *argv[])
{
	int msgid;
	msgid = msgget(0x1234, IPC_CREAT | 0666);
	if (msgid == -1)
		ERR_EXIT("msgget");

	echo_srv(msgid);

	return 0;
}


形形色色的人
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux--进程间通信之消息队列
我的博客
06-20 588
什么是消息队列 1.消息队列，是消息的链接表，存放在内核中。 2.一个消息队列由一个标识符（即队列ID）来标识。 3.因为消息队列其实就是一个链表，所以往消息队列里面发送数据就等价于向链表里面插入一个消息结点，从消息队列里面取数据就等价于访问该结点，访问完后再删除这个结点。 消息队列的特点 1.消息队列可用于任意两个进程进行进程间通信（只要这两个进程能够看到同一个消息队列就可以）； 2...
进程间通信——消息队列（Message queue）
ypt
04-16 2266
在Linux中，IPC消息队列是一个双向通信的全内存设计，即内核保证了读写顺序和数据同步，并且是性能比较好的先进先出的数据结构。消息队列的应用场景：比如异步任务处理，抢占式的数据分发，顺序缓存区等。消息队列的产生原因消息队列其实就是消息传输过程中保存消息的容器，既然有了管道，为什么要出现消息队列呢？理由如下：（1）生命周期：匿名管道和命名管道都是随进程的，意味着管道的生命周期是随进程的退出而退出的...
PHP的msg_get_queue返回false的问题
tshichun
02-16 1216
在用消息队列做进程间通信时遇到的一个小问题
消息队列msgqueue
嵌入式与人工智能
08-20 546
消息发送与接受： msg_a.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <signal.h> #define MSG_TYPE_A 100 #define MSG_TYPE_B 200 ty
linux msg queue 基础操作
abc1104332737的博客
01-11 221
#include <sys/types.h> #include <sys/msg.h> #include <unistd.h> #include <string.h> #include <stdio.h> void msg_stat(int,struct msqid_ds ); int main() { ...
linux进程间通信之消息队列
renrenhappy的专栏
09-03 6906
<br />        上周因课题的需要，写了一个进程间使用消息队列通信的程序。之所以，用因为消息队列是随内核存在的，即使进程退出它仍然存在 。消息队列的这种特点正适合我的需要。下面是来自CSDN博客上的一篇文章，转自http://blog.csdn.net/liranke/archive/2010/05/19/5608686.aspx<br />1. 基本概念<br />消息队列的最佳定义是：内核地址空间中的内部链表。消息可以顺序地发送到队列中，<br />并以几种不同的方式从队列中获取。当然，每个
Linux进程间通信之消息队列
LLZK_的博客
03-03 1260
消息队列我们可以把消息队列理解为共享的消息链表，它存储在内核中，由消息队列标识符标识。消息队列传输数据的单位是有类型的数据块，这点与管道不同，管道的信息传输是基于字节流。 不同进程发送的数据块可被认为都有自己的类型，而接受端进程接受的数据块可以有不同的类型。 消息队列与管道相同的地方在于他们都是有限的。及既然他们都是一块共享的内存，那么他们必定有大小。 msgmax，每个消息的最大长度是有上限
Linux进程间通信：消息队列
01-20
消息队列允许一个或多个进程向它写入与读取消息. 　3.管道和命名管道都是通信数据都是先进先出的原则。 　4.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取.比FIFO更...
linux进程间通信消息队列信号量共享内存等.pptx
10-16
Linux进程间通信（IPC，Inter-Process Communication）是操作系统中多进程协同工作的重要机制，它允许不同进程之间交换数据和协调执行。在这个主题中，我们将深入探讨System V IPC和POSIX IPC接口，这两种机制在...
linux c 进程间通信 消息队列
03-01
本教程将深入探讨Linux C语言中如何利用消息队列进行进程间通信，并提供亲测可用的代码示例。 首先，理解消息队列的基本概念。消息队列是一种特殊的文件系统对象，它允许一个进程发送消息到另一个进程，即使接收...
linux进程间通信消息队列、信号量、共享内存等.ppt
09-16
linux进程间通信消息队列、信号量、共享内存等.ppt
进程间通信之深入消息队列的详解
01-20
消息队列是操作系统提供的一种进程间通信机制，它允许进程之间通过传递消息的方式进行通信，尤其在多进程环境中，消息队列展现出了其强大的灵活性和实用性。本文将深入讲解消息队列的概念、特点以及相关函数的使用。...
【进程间通信】-------消息队列（msgqueue）
daboluo521的博客
04-21 1967
认识消息队列 消息队列提供了一个从一个进程向另外一个进程发送一块（有类型）数据的方法。 每个数据块都被认为是一个类型，接收者进程接收的数据块可以有不同的类型值。 消息队列也有管道一样的不足，就是每个消息的最大长度是有上限的(MSGMAX），就是每个消息队列的总的字节数是有上限的（MSGMNB），系统上消息队列的总数也有个上限（MSGMNI）。 IPC对象数据结构/usr/include/li...
消息队列和GetMessage/PeekMessage、SendMessage/Postmesage的详解
01-08 1408
一、消息队列 1.1 消息队列 消息队列是用来存放消息的一个队列，消息在队列中先入先出，所有的窗口程序都具有消息队列，程序可以从队列中获取消息。 1.2 消息队列的类型 系统消息队列：由操作系统维护的消息队列，存放系统产生的消息，如鼠标、键盘消息等等。 程序消息队列：属于每一个应用程序（线程）的消息队列，用应用程序维护。 当产生鼠标、键盘等消息时，消息先存放到系统消息队列，然后操作系统...
linux进程通信之消息队列：msg queue
野生猿-群号1025127672
07-02 1810
shell 相关命令：ipcs -q -s -m#查看已建立的队列、信号量（semaphore，又译信号灯）、共享内存 ipcrm -q 123  #删除id=123的消息队列   一、接口函数：（下述内容基本上翻译的官方man手册，有一些我理解不了的句子，就直接把原文贴上来了） 1、key_t ftok(const char *pathname, int proj_id)，由文件路径（文...
Windows 消息陷阱
FreeWave's space
01-21 3748
  也许题目有些夸张，但是Windows消息方面确实存在一些不去探究就摸不着头脑的事情，这种问题不是明显错误，不会抛出异常，但却是最棘手的问题，给调试带来很大麻烦，所以我将实际遇到的问题整理如下，以供参考。 一、Windows 消息以及消息处理算法Windows以消息驱动的方式，使得线程能够通过处理消息来响应外界。Windows 为每个需要接受消息和处理消息的线程建立消息队列（包括发送
PHP 进程间通信——消息队列(msg_queue)
weixin_30951231的博客
12-27 448
Untitled PHP 进程间通信——消息队列 本文不涉及PHP基础库安装。详细安装说明，请参考官网，或期待后续博客分享。 1、消息队列函数准备 <?php//生成一个消息队列的key$msg_key = ftok(__FILE__, 'a');//产生一个消...
Linux下的消息队列MsgQueue
ZoctopusD的博客
05-15 2514
server文件运行时先收消息再发消息，但是server.c中创建了消息队列，所以先运行server client文件运行时先发消息再收消息 运行结果：打开两个terminal分别进行 comm.h头文件 1 #ifndef _COMM_H_ 2 #define _COMM_H_ 3 4 5 #include 6 #include 7 #includ
linux 信号量 同步多进程
nuptxiaoli
11-14 3549
int semget(key_t key, int nsems, int semflg); int semctl(int semid, int semnum, int cmd, ...); int semop(int semid, struct sembuf *sops, unsigned nsops);
LinuX 进程间通信之消息队列
最新发布
05-18
Linux 进程间通信中的消息队列是一种高效的通信方式。它允许进程之间通过一个消息队列来传递数据，而无需直接相互通信。 消息队列可以被认为是一个消息缓冲区，其中一个进程可以向其写入消息，另一个进程可以从中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值