消息队列本质上是位于内核空间的链表，链表的每个节点都是一条消息。每一条消息都有自己的消息类型，消息类型用整数来表示，而且必须大于 0。每种类型的消息都被对应的链表所维护：
其中数字 1 表示类型为 1 的消息，数字2、3、4 类似。彩色块表示消息数据，它们被挂在对应类型的链表上。
值得注意的是，刚刚说过没有消息类型为 0 的消息，实际上，消息类型为 0 的链表记录了所有消息加入队列的顺序，其中红色箭头表示消息加入的顺序。
无论你是发送还是接收消息，消息的格式都必须按照规范来。简单的说，它一般长成下面这个样子：
所以，只要你保证首4字节(32 位 linux 下的 long)是一个整数就行了。
举个例子：
从上面可以看出，正文部分是什么数据类型都没关系，因为消息队列传递的是 2 进制数据，不一定非得是文本。
msgsnd 函数用于将数据发送到消息队列。如果该函数被信号打断，会设置 errno 为 EINTR。
参数 msqid：ipc 内核对象 id
参数 msgp：消息数据地址
参数 msgsz：消息正文部分的大小（不包含消息类型）
参数 msgflg：可选项
该值为 0：如果消息队列空间不够，msgsnd 会阻塞。
IPC_NOWAIT：直接返回，如果空间不够，会设置 errno 为 EAGIN.
返回值：0 表示成功，-1 失败并设置 errno。
msgrcv 函数从消息队列取出消息后，并将其从消息队列里删除。
参数 msqid：ipc 内核对象 id
参数 msgp：用来接收消息数据地址
参数 msgsz：消息正文部分的大小（不包含消息类型）
参数 msgtyp：指定获取哪种类型的消息
msgtyp = 0：获取消息队列中的第一条消息
msgtyp > 0：获取类型为 msgtyp 的第一条消息，除非指定了 msgflg 为MSG_EXCEPT，这表示获取除了 msgtyp 类型以外的第一条消息。
msgtyp < 0：获取类型 ≤|msgtyp|≤|msgtyp| 的第一条消息。
参数 msgflg：可选项。
如果为 0 表示没有消息就阻塞。
IPC_NOWAIT：如果指定类型的消息不存在就立即返回，同时设置 errno 为 ENOMSG
MSG_EXCEPT：仅用于 msgtyp > 0 的情况。表示获取类型不为 msgtyp 的消息
MSG_NOERROR：如果消息数据正文内容大于 msgsz，就将消息数据截断为 msgsz
程序 msg_send 和 msg_recv 分别用于向消息队列发送数据和接收数据。
msg_send 程序定义了一个结构体 Msg，消息正文部分是结构体 Person。该程序向消息队列发送了 10 条消息。
msg_send.c
程序 msg_send 第一次运行完后，内核中的消息队列大概像下面这样：
msg_recv 程序接收一个参数，表示接收哪种类型的消息。比如./msg_recv 4 表示接收类型为 4 的消息，并打印在屏幕。
先运行 msg_send，再运行 msg_recv。
接收所有消息
接收类型为 4 的消息
获取和设置消息队列的属性
msqid：消息队列标识符
cmd：控制指令
IPC_STAT:获得msgid的消息队列头数据到buf中
IPC_SET：设置消息队列的属性，要设置的属性需先存储在buf中，可设置的属性包括：msg_perm.uid、msg_perm.gid、msg_perm.mode以及msg_qbytes
buf：消息队列管理结构体。
返回值：
成功：0
出错：-1，错误原因存于error中
EACCESS：参数cmd为IPC_STAT，确无权限读取该消息队列
EFAULT：参数buf指向无效的内存地址
EIDRM：标识符为msqid的消息队列已被删除
EINVAL：无效的参数cmd或msqid
EPERM：参数cmd为IPC_SET或IPC_RMID，却无足够的权限执行
② linux 消息队列接收端如何知道有消息过来了
好像没有判断消息队列是否有消息可读的机制（不像网络的select可通过结果得到可读可写的socket状态），你只要用msgrcv（）循环去读取就好了 如果消息有类型 可以根据特定的类型去读，不设置类型去读的话就会读走队列的第一条，队列的消息读取之后就从队列里面移出了。
③ linux C ，消息队列问题，急求
将long msg_type; 作为
struct student 结构体的第一个成员就可以了。
这样，你的消息结构体就是 struct student
{
long msg_type；
char name[100];
int age;
char sex[4];
};
就可以作为一个完整的消息发送了，msgsnd 查看man手册
④ 如何在linux下看消息队列是否存在
#include
#include
#include
#include types.h>
#include msg.h>
#include
#include ipc.h>
void msg_show_attr(int msg_id, struct msqid_ds msg_info)
{
int ret = -1;
sleep(1);
ret = msgctl(msg_id, IPC_STAT, &msg_info);
if( -1 == ret)
{
printf(获消息信息失败\n);
return ;
}
printf(\n);
printf(现队列字节数：%d\n,msg_info.msg_cbytes);
printf(队列消息数：%d\n,msg_info.msg_qnum);
printf(队列字节数：%d\n,msg_info.msg_qbytes);
printf(发送消息进程pid：%d\n,msg_info.msg_lspid);
printf(接收消息进程pid：%d\n,msg_info.msg_lrpid);
printf(发送消息间：%s,ctime(&(msg_info.msg_stime)));
printf(接收消息间：%s,ctime(&(msg_info.msg_rtime)));
printf(变化间：%s,ctime(&(msg_info.msg_ctime)));
printf(消息UID：%d\n,msg_info.msg_perm.uid);
printf(消息GID：%d\n,msg_info.msg_perm.gid);
}
int main(void)
{
int ret = -1;
int msg_flags, msg_id;
key_t key;
struct msgmbuf{
int mtype;
char mtext[10];
};
struct msqid_ds msg_info;
struct msgmbuf msg_mbuf;
int msg_sflags,msg_rflags;
char *msgpath = /ipc/msg/;
key = ftok(msgpath,’a');
if(key != -1)
{
printf(功建立KEY\n);
}
else
{
printf(建立KEY失败\n);
}
msg_flags = IPC_CREAT;
msg_id = msgget(key, msg_flags|0666);
if( -1 == msg_id)
{
printf(消息建立失败\n);
return 0;
}
msg_show_attr(msg_id, msg_info);
msg_sflags = IPC_NOWAIT;
msg_mbuf.mtype = 10;
memcpy(msg_mbuf.mtext,测试消息,sizeof(测试消息));
ret = msgsnd(msg_id, &msg_mbuf, sizeof(测试消息), msg_sflags);
if( -1 == ret)
{
printf(发送消息失败\n);
}
msg_show_attr(msg_id, msg_info);
msg_rflags = IPC_NOWAIT|MSG_NOERROR;
ret = msgrcv(msg_id, &msg_mbuf, 10,10,msg_rfla
共享内存示例代码：
#include
#include sem.h>
#include ipc.h>
#include
typedef int sem_t;
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
} arg;
sem_t CreateSem(key_t key, int value)
{
union semun sem;
sem_t semid;
sem.val = value;
semid = semget(key,value,IPC_CREAT|0666);
if (-1 == semid)
{
printf(create semaphore error\n);
return -1;
}
semctl(semid,0,SETVAL,sem);
return semid;
}
/*
struct sembuf{
ushort sem_num;
short sem_op;
short sem_flg;
};
*/
void SetvalueSem(sem_t semid, int value)
{
union semun sem;
sem.val = value;
semctl(semid,0,SETVAL,sem);
return ;
}
int GetvalueSem(sem_t semid)
{
union semun sem;
return semctl(semid,0,GETVAL,sem);
return sem.val;
}
void DestroySem(sem_t semid)
{
union semun sem;
sem.val = 0;
semctl(semid,0,IPC_RMID,sem);
}
int Sem_P(sem_t semid)
{
struct sembuf sops={0,+1,IPC_NOWAIT};
return (semop(semid,&sops,1));
}
int Sem_V(sem_t semid)
{
struct sembuf sops={0,-1,IPC_NOWAIT};
return (semop(semid,&sops,1));
}
static char msg[]=共享内存\n;
int main(void)
{
key_t key;
int semid,shmid;
char i,*shms,*shmc;
struct semid_ds buf;
int value = 0;
char buffer[80];
pid_t p;
key = ftok(/ipc/sem/,’a');
shmid = shmget(key,1024,IPC_CREAT|0604);
semid = CreateSem(key,1);
p = fork();
if(p > 0)
{
/* 父进程 */
/* 建立共享内存 */
shms = (char *)shmat(shmid,0,0);
memcpy(shms, msg, strlen(msg)+1);
sleep(10);
Sem_P(semid);
shmdt(shms);
DestroySem(semid);
}
else if(p == 0)
{
shmc = (char *)shmat(shmid,0,0);
Sem_V(semid);
printf(共享内存值:%s\n,shmc);
shmdt(sg_
⑤ Linux中查看进程状态信息
一、常用命令总结
二、进程简述及查看方式
三、进程信息的查看
2.1 列出与 本次登录系统 有关的进程信息
2.2 列出在内存中运行的 全部进程信息
2.3 动态显示内存中的进程信息（top）
四、进程的清除
注：有些进程是不允许停止的，因为停止会造成系统的不稳定，甚至崩溃。（网上搜索进程知识了解更多）
五 删除相关进程
如，要 kill 掉 swoole 相关的进程
ps 列出所有进程，
参数：
也就是将管道传递过来的每一个 PID 作为 kill -9 的参数
⑥ 在linux中，消息与信号的异同点
相同点：
消息和信号的运用都可以为任务事件驱动
不同点：
1、信号只能是固定的几个（如SIGINT），且接收对象只能是进程。而消息的对象可以是进程，也可以为线程。
2、信号不需要创建，系统是识别的，用kill -l 可以查看完整的信号列表，没有大小的讨论。消息需要申请消息队列资源，返回的是消息队列的句柄，打进的消息体长度、消息的数量、消息队列总的容量只受系统消息队列配置大小的限制。
3、消息在linux系统中，由用户层进入内核层队列，全为复制操作，代价是4次拷贝。信号也需要调用系统调用，但信号本身成本低。
4、另外信号的使用会使阻塞的进程被中断掉。而消息没有这个功能。
⑦ linux进程间通信（消息队列）
在与此进程P1通信的进程P2中，同样的以ftok创建KEY, msgget在该KEY上创建消息队列，
只需要保证，ftok的参数中，第一个参数，即文件，是同一个文件即可。当P2中的文件与P1不同时，msgget函数将会返回错误。
可以说，消息队列也是通过文件实现的，就像创建一个socket，要使用它时，也已经为其绑定了一个文件fd。
有一个例子不错，你可以看看。实验时，需要把ftok的第一个参数，即文件，设置为一个你当前目录存在的文件。你可以touch一个临时文件来实验。
http://blog.csdn.net/lcrystal623/archive/2007/03/16/1531183.aspx
同时，谢谢link的博主。
⑧ Linux多线程同步之消息队列有何特点
消息队列是消息的链表，存放在内核中并有消息队列标示符标示。
msgget用于创建一个新队列或打开一个现存的队列。msgsnd将新消息加入到消息队列中；每个
消息包括一个long型的type；和消息缓存；msgrcv用于从队列中取出消息；取消息很智能，不一定先进先出
①msgget，创建一个新队列或打开一个现有队列
#include
int msgget ( key_t key, int flag )；
//成功返回消息队列ID；错误返回-1
②msgsnd: 发送消息
#include
int msgsnd( int msgid, const void* ptr, size_t nbytes, int flag )
//成功返回0，错误返回-1
a:
flag可以指定为IPC_NOWAIT;
若消息队列已满，则msgsnd立即出错返回EABAIN；
若没指定IPC_NOWAIT； msgsnd会阻塞，直到消息队列有空间为止
③msgrcv: 读取消息：
ssize_t msgrcv( int msgid, void* ptr, size_t nbytes, long type, int flag );
a. type == 0; 返回消息队列中第一个消息，先进先出
b. type > 0
返回消息队列中类型为tpye的第一个消息
c. type < 0
返回消息队列中类型 <=
|type| 的数据；若这种消息有若干个，则取类型值最小的消息
消息队列创建步骤：
#define
MSG_FILE "."
struct msgtype {
long mtype;
char buffer[BUFFER+1];
};
if((key=ftok(MSG_FILE,'a'))==-1)
{
fprintf(stderr,"Creat Key Error:%s\n", strerror(errno));
exit
(1);
}
if((msgid=msgget(key, IPC_CREAT | 0666/*PERM*/))==-1)
{
fprintf(stderr,"Creat Message
Error:%s\n", strerror(errno));
exit
(1);
}
⑨ LINUX 消息队列读写问题
消息队列是随内核持续存在的，里面的消息是被读取时就被删掉了。消息队列和消息是不一样的。我是这样理解的。
⑩ 如何用JAVA实现Linux上的消息队列功能
下面来说说如何用不用消息队列来进行进程间的通信，消息队列与命名管道有很多相似之处。有关命名管道的更多内容可以参阅我的另一篇文章：Linux进程间通信——使用命名管道
一、什么是消息队列
消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制。
Linux用宏MSGMAX和MSGMNB来限制一条消息的最大长度和一个队列的最大长度。
二、在Linux中使用消息队列
Linux提供了一系列消息队列的函数接口来让我们方便地使用它来实现进程间的通信。它的用法与其他两个System V PIC机制，即信号量和共享内存相似。
1、msgget函数
该函数用来创建和访问一个消息队列。它的原型为：
int msgget(key_t, key, int msgflg);
与其他的IPC机制一样，程序必须提供一个键来命名某个特定的消息队列。msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。
它返回一个以key命名的消息队列的标识符（非零整数），失败时返回-1.
2、msgsnd函数
该函数用来把消息添加到消息队列中。它的原型为：
int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);
msgid是由msgget函数返回的消息队列标识符。
msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。所以消息结构要定义成这样：
struct my_message{
long int message_type;
/* The data you wish to transfer*/
};
msg_sz是msg_ptr指向的消息的长度，注意是消息的长度，而不是整个结构体的长度，也就是说msg_sz是不包括长整型消息类型成员变量的长度。
msgflg用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情。
如果调用成功，消息数据的一分副本将被放到消息队列中，并返回0，失败时返回-1.
3、msgrcv函数
该函数用来从一个消息队列获取消息，它的原型为
int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);
msgid, msg_ptr, msg_st的作用也函数msgsnd函数的一样。
msgtype可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
msgflg用于控制当队列中没有相应类型的消息可以接收时将发生的事情。
调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1.
4、msgctl函数
该函数用来控制消息队列，它与共享内存的shmctl函数相似，它的原型为：
int msgctl(int msgid, int command, struct msgid_ds *buf);
command是将要采取的动作，它可以取3个值，
IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。
IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
IPC_RMID：删除消息队列
buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。msgid_ds结构至少包括以下成员：
struct msgid_ds
{
uid_t shm_perm.uid;
uid_t shm_perm.gid;
mode_t shm_perm.mode;
};
成功时返回0，失败时返回-1.
三、使用消息队列进行进程间通信
马不停蹄，介绍完消息队列的定义和可使用的接口之后，我们来看看它是怎么让进程进行通信的。由于可以让不相关的进程进行行通信，所以我们在这里将会编写两个程序，msgreceive和msgsned来表示接收和发送信息。根据正常的情况，我们允许两个程序都可以创建消息，但只有接收者在接收完最后一个消息之后，它才把它删除。
接收信息的程序源文件为msgreceive.c的源代码为：
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/msg.h>
struct msg_st
{
long int msg_type;
char text[BUFSIZ];
};
int main()
{
int running = 1;
int msgid = -1;
struct msg_st data;
long int msgtype = 0; //注意1
//建立消息队列
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if(msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d\n", errno);
exit(EXIT_FAILURE);
}
//从队列中获取消息，直到遇到end消息为止
while(running)
{
if(msgrcv(msgid, (void*)&data, BUFSIZ, msgtype, 0) == -1)
{
fprintf(stderr, "msgrcv failed with errno: %d\n", errno);
exit(EXIT_FAILURE);
}
printf("You wrote: %s\n",data.text);
//遇到end结束
if(strncmp(data.text, "end", 3) == 0)
running = 0;
}
//删除消息队列
if(msgctl(msgid, IPC_RMID, 0) == -1)
{
fprintf(stderr, "msgctl(IPC_RMID) failed\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
发送信息的程序的源文件msgsend.c的源代码为：
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/msg.h>
#include <errno.h>
#define MAX_TEXT 512
struct msg_st
{
long int msg_type;
char text[MAX_TEXT];
};
int main()
{
int running = 1;
struct msg_st data;
char buffer[BUFSIZ];
int msgid = -1;
//建立消息队列
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if(msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d\n", errno);
exit(EXIT_FAILURE);
}
//向消息队列中写消息，直到写入end
while(running)
{
//输入数据
printf("Enter some text: ");
fgets(buffer, BUFSIZ, stdin);
data.msg_type = 1; //注意2
strcpy(data.text, buffer);
//向队列发送数据
if(msgsnd(msgid, (void*)&data, MAX_TEXT, 0) == -1)
{
fprintf(stderr, "msgsnd failed\n");
exit(EXIT_FAILURE);
}
//输入end结束输入
if(strncmp(buffer, "end", 3) == 0)
running = 0;
sleep(1);
}
exit(EXIT_SUCCESS);
}
转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦