一、消息队列的特点

    1.消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识.
    2.消息队列允许一个或多个进程向它写入与读取消息.
    3.管道和命名管道都是通信数据都是先进先出的原则。
    4.消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取.比FIFO更有优势。

    目前主要有两种类型的消息队列：POSIX消息队列以及系统V消息队列，系统V消息队列目前被大量使用。系统V消息队列是随内核持续的，只有在内核重起或者人工删除时，该消息队列才会被删除。

二、相关函数

1. 获得key值

    key_t ftok(char *pathname, int projid)

#include <sys/types.h>
#include <sys/ipc.h>
参数:
    pathname：文件名（含路径）,通常设置为当前目录“.”
    projid：项目ID，必须为非0整数（0-255）. 

2. 创建消息队列
    int msgget(key_t key, int msgflag)
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
功能：
    用于创建一个新的或打开一个已经存在的消息队列，此消息队列与key相对应。
参数：
    key：函数ftok的返回值或IPC_PRIVATE。
    msgflag：
        IPC_CREAT:创建新的消息队列。
        IPC_EXCL:与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
        IPC_NOWAIT:读写消息队列要求无法满足时，不阻塞。
返回值：
    调用成功返回队列标识符,否则返回-1.

在以下两种情况下，将创建一个新的消息队列：
    1、如果没有与键值key相对应的消息队列，并且msgflag中包含了IPC_CREAT标志位。
    2、key参数为IPC_PRIVATE。 

3. 消息队列属性控制
    int msgctl(int msqid,  int cmd,  struct msqid_ds *buf)
功能:
对消息队列进行各种控制操作,操作的动作由cmd控制。
参数:
    msqid:消息队列ID，消息队列标识符，该值为msgget创建消息队列的返回值。
    cmd:
        IPC_STAT:将msqid相关的数据结构中各个元素的当前值存入到由buf指向的结构中.
        IPC_SET:将msqid相关的数据结构中的元素设置为由buf指向的结构中的对应值.
        IPC_RMID:删除由msqid指示的消息队列,将它从系统中删除并破坏相关数据结构.
buf:消息队列缓冲区
    struct msqid_ds {
              struct ipc_perm msg_perm;          /* Ownership and permissions*/
              time_t        msg_stime;                /* Time of last msgsnd() */
              time_t        msg_rtime;                  /* Time of last msgrcv() */
              time_t        msg_ctime;                /* Time of last change */
              unsigned long  __msg_cbytes;    /* Current number of bytes in  queue (non-standard) */
              msgqnum_t      msg_qnum;          /* Current number of messages  in queue */
              msglen_t      msg_qbytes;          /* Maximum number of bytesallowed in queue */
              pid_t          msg_lspid;                  /* PID of last msgsnd() */
              pid_t          msg_lrpid;                  /* PID of last msgrcv() */
                    };

    struct ipc_perm {
              key_t key;                        /* Key supplied to msgget() */
              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 */
                  };

4．发送信息到消息队列
    int msgsnd(int msqid,  struct msgbuf *msgp,  size_t msgsz,  int msgflag)
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
功能:

    将新消息添加到队列尾端,即向消息队列中发送一条消息。
参数：
    msqid:已打开的消息队列id
    msgp:存放消息的结构体指针。
    msgflag:函数的控制属性。
    消息结构msgbuf为:
    struct msgbuf
    {
        long mtype;//消息类型
        char mtext[1];//消息正文，消息数据的首地址
    }
    msgsz:消息数据的长度。
    msgflag:
    IPC_NOWAIT: 指明在消息队列没有足够空间容纳要发送的消息时，msgsnd立即返回。
    0:msgsnd调用阻塞直到条件满足为止.（一般选这个）

5. 从消息队列接收信息
    ssize_t msgrcv(int msqid,  struct msgbuf *msgp,  size_t msgsz,  long msgtype,  int msgflag)
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
功能:

    从队列中接收消息
参数:
    msqid:已打开的消息队列id
    msgp:存放消息的结构体指针。
    msgsz:消息的字节数，指定mtext的大小。
    msgtype:消息类型，消息类型 mtype的值。
    msgflag:函数的控制属性。
    msgflag:
        MSG_NOERROR:若返回的消息比nbytes字节多,则消息就会截短到nbytes字节,且不通知消息发送进程.
        IPC_NOWAIT:调用进程会立即返回.若没有收到消息则返回-1.
        0:msgrcv调用阻塞直到条件满足为止.
在成功地读取了一条消息以后，队列中的这条消息将被删除。

例如：简单的消息收发

#include <sys/types.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>

struct msg_buf
{
int mtype;
char data[255];
};

int main( int argc, char *argv[] )
{
key_t key;
int msgid;
int ret;
struct msg_buf msgbuf;
//get key
key = fork( ".", "a" );
printf( "key = [%x]\n", key );
//create quee
msgid = msgget( key, IPC_CREATE|0666 );
if( msgid = -1 )
{
printf( "create err!\n" );
return -1;
}
//以当前进程类型，非阻塞方式发送"test data"到消息队列
msgbuf.mtype = getpid();
stpcpy( msgbuf.data, "test data" );
ret = msgsnd( msgid; &msgbuf, sizeof( msgbuf.data), IPC_NOWAIT );
if( ret == -1 )
{
printf( "send err!\n" );
return -1;
}
//以非阻塞方式接收数据
memset ( &msgbuf, 0x00, sizeof( msgbuf) );
ret = msgrcv( msgid, &msgbuf, sizeof( msgbuf.data), getpid(), IPC_NOWAIT );
if( ret == -1 )
{
printf( "rcv_err ret =[%d]!\n", ret );
return -1;
}
printf( "receive msg = [%s]\n!" , msgbuf.data );
return 0;
}

同一消息队列通信：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h> //要加这个头文件

struct msgbuf{
long mtype;
char mtext[100];
}; //存放消息类型和消息内容的结构体

int main()
{
key_t key;
int msgid;
struct msgbuf msg1,msg2; //msg1用来发送，msg2用来接收

key=ftok(".", 0xf0); //获得消息队列标识符
if( (msgid = msgget(key, IPC_CREAT|0666)) < 0 ) //创建一个消息队列
{
perror("msgget error");
exit(1);
}
msg1.mtype = 1; //消息类型为1，这个可以区别多个消息
memset(msg1.mtext, 0, 100); //将数组清0
strcpy(msg1.mtext, "hello"); //用strcpy给消息内容赋值
msgsnd(msgid, &msg1, strlen(msg1.mtext)+1, 0); //发送时最后加上一个‘\0’
printf("send %s\n", msg1.mtext);

msgrcv(msgid, &msg2, 100, 1, 0); //接收1发过来的消息，存到msg2中
printf("receive %s\n", msg2.mtext);

msgctl(msgid, IPC_RMID,NULL); //删除消息队列
return 0;
}

进程间消息队列通信：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <string.h>
#include <signal.h>

struct msgbuf{
int mtype;
char mtext[100];
};

int main()
{
key_t key;
pid_t pid;
int msgid;
struct msgbuf msg;

key=ftok(".", 0x01);
if ( (msgid = msgget(key, IPC_CREAT|0666)) <0 )
{
perror("msgget error");
exit(1);
}

//创建一个进程
if ( (pid = fork()) < 0 )
{
perror("fork error");
exit(1);
}
//子进程收信息
else if (pid==0)
{
while(1)
{
memset(msg.mtext,0,100);
msgrcv(msgid,&msg,100,2,0); //receive the msg from 2
printf("\rbbb:%s\naaa:",msg.mtext);
fflush(stdout);
}
exit(0);
}
//父进程发信息
else
{
while(1)
{
memset(msg.mtext,0,100);
printf("aaa:");
fgets(msg.mtext,100,stdin);
if (strncmp("bye",msg.mtext,3)==0)//如果前3个字符为bye,则退出
{
kill(pid,SIGSTOP);
exit(1);
}
msg.mtype=1;//send to 1
msg.mtext[strlen(msg.mtext)-1]='\0';
msgsnd(msgid,&msg,strlen(msg.mtext)+1,0);
}
}

return 0;
}