一文带你入门POSIX消息队列

引入

POSIX消息队列， 它和原来学的System V消息队列（msgget、msgsnd， msgrcv）类似，都是用以队列的形式传递消息。接口主要有以下几个：

POSIX 与 System V消息队列对比:

System V消息队列：

主要函数(API):

头文件

               #include <sys/msg.h>

    int msgget(key_t key, int oflag)
    int msgsnd(int msqid, constvoid * ptr, size_t length, int flag)
    ssize_t msgrcv (int msqid, void*ptr, size_t length, long type, int flag)
    int msgctl (int msqid, int cmd,    struct msqid_ds *buf)

基本用法:

1.创建或获取消息队列：

使用msgget()函数来创建或获取一个消息队列。
该函数接受一个键（key）和一个标志（flag）作为参数。
如果键的值为IPC_PRIVATE或当前没有消息队列与给定键相关联，将会创建一个新的消息队列。
标志位可以用来指定权限组合。

2. 往消息队列中放入消息：

使用msgsnd()函数来往一个消息队列中放入一个消息。
该函数接受四个参数，分别为消息队列标识符、指向消息的指针、消息的大小以及标志位。
成功放入消息后，该函数返回0，否则返回-1并设置errno来表示错误原因。

3. 从消息队列中读取消息：

使用msgrcv()函数来从一个消息队列中读取一个消息。
该函数接受五个参数，分别为

消息队列标识符、指向消息的指针、消息的最大大小、消息的类型以及标志位。
成功读取消息后，该函数返回读取到的消息的大小，否则返回-1并设置errno来表示错误原因。

4. 控制消息队列：

使用msgctl()函数来对一个消息队列进行控制操作，如删除、设置权限等。
该函数接受三个参数，分别为消息队列标识符、操作命令以及一个可选的参数

=========================================================

POSIX 消息队列

主要函数(API）

头文件
   #include <mqueue.h>

mqd_t mq_open(const char *name, int oflag,mode_t mode, struct mq_attr attr );
int mq_close(mqd_t mqdes);//
int mq_unlink(const char *name);
int mq_getattr(mqd_t mqdes, struct mq_attr *attr);
int mq_setattr(mqd_t mqdes, struct mq_attr *attr,struct mq_attr *oattr);
int mq_send(mqd_t mqdes, const char *ptr, size_tlen, unsigned int prio);
ssize_t mq_receive(mqd_t mqdes, char *ptr, size_tlen, unsigned int *prio);
int mq_notify(mqd_t mqdes, const struct sigevent*notification);

基本用法:

1.创建或打开消息队列：

使用mqd_t mq_open(constchar *name,int oflag,mode_t mode,struct mq_attr*attr);函数来创建或打开一个消息队列。
该函数接受队列名称、打开标志以及可选的权限和属性作为参数。
如果队列不存在且指定了创建标志，将会创建一个新的消息队列。
成功创建或打开后，函数返回一个消息队列描述符（mqd_t）。

2. 发送消息：

使用int mq_send(mqd_t mqdes,constchar *msg_ptr,size_t msg_len,unsigned intmsg_prio);函数来发送一个消息到指定的消息队列。
该函数接受消息队列描述符、指向消息的指针以及消息的大小作为参数。
发送消息时，可以指定消息的优先级，较高的优先级数值表示较高的优先级。
成功发送后，函数返回0，否则返回-1并设置errno来表示错误原因。

3. 接收消息：

使用ssize_t mq_receive(mqd_tmqdes, char *mdg_ptr,size_t msg_len,unsigned int*msg_prio);函数来从指定的消息队列中接收一个消息。
该函数接受消息队列描述符、指向接收缓冲区的指针以及缓冲区的最大大小作为参数。
接收消息时，可以选择按优先级接收，也可以选择非阻塞接收。成功接收后，函数返回接收到的消息的大小，否则返回-1并设置errno来表示错误原因。

4. 关闭消息队列：

使用int mq_close(mqd_t mqdes);函数来关闭一个已打开的消息队列。
该函数接受消息队列描述符作为参数。关闭消息队列后，相关的资源将被释放。

5. 删除消息队列：

使用int mq_unlink(const char*name);函数来删除一个已存在的消息队列。
该函数接受队列名称作为参数。删除一个消息队列将会移除与之关联的所有消息和状态.

2、3步可以改成下面的6、7、8步，支持异步通知:

6. 设置异步通知：

使用int mq_notify(mqd_tmqdes,const struct sigevent *notification);函数来注册一个进程以接收异步通知。
该函数接受消息队列描述符、一个指向sigevent结构的指针以及一个通知标志作为参数。
在sigevent结构中，可以设置当消息到达时要发送的信号或者要调用的回调函数。
通过设置用int mq_notify(mqd_t mqdes,const structsigevent *notification);，
当消息队列从空变为非空时，已注册的进程将收到一个信号或触发一个回调函数，以异步地通知该进程

7. 发送消息：

使用int mq_send(mqd_t mqdes,constchar *msg_ptr,size_t msg_len,unsigned intmsg_prio);函数来发送一个消息到指定的消息队列。
该函数接受消息队列描述符、指向消息的指针以及消息的大小作为参数。
发送消息时，可以指定消息的优先级，较高的优先级数值表示较高的优先级。成功发送后，函数返回0，否则返回-1并设置errno来表示错误原因。

8.处理异步通知：

当有新消息到达时，已注册的进程将收到一个信号或触发一个回调函数。
在信号处理函数或回调函数中，可以执行相关的操作来处理新到达的消息。
例如，可以调用ssize_t mq_receive(mqd_tmqdes, char *mdg_ptr,size_t msg_len,unsigned int*msg_prio);来接收并处理消息。

其他说明：

1. mqd_t mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr) 中

oflag和mode 参数说明

参数oflag：同int open(const char *pathname, int flags, mode_t mode);函数的的oflag类似有
O_RDONLY、O_RDWR， O_WRONLY，除此之外还有 O_CREAT、O_EXCL（如果 O_CREAT 指定，但name 不存在，就返回错误），O_NONBLOCK（以非阻塞方式打开消息队列，在正常情况下mq_receive和mq_send 函数会阻塞的地方，使用该标志打开的消息队列会返回 EAGAIN 错误）。

参数mode：同int open(const char *pathname, int flags, mode_t mode);函数的mode参数，用于指定权限位， 比如0644权限

-----------------------------

包含的结构体: 

struct mq_attr
{
long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK
long mq_maxmsg;//最大消息数
long mq_msgsize;//每个消息最大大小
long mq_curmsgs;//当前消息数
};

 struct sigevent和sigval_t sigev_val 的定义如下：

union sigval { /* 传递给通知的数据 */
    int sival_int;       /* 整型值 */
    void *sival_ptr;     /* 指针值 */
};

struct sigevent {
    int sigev_notify;    /* 通知方式 */
    int sigev_signo;     /* 通知信号 */
    union sigval sigev_value; /* 传递给通知的数据 */
    void (*sigev_notify_function) (union sigval); /* 线程通知使用的函数 (SIGEV_THREAD) */
    void *sigev_notify_attributes; /* 通知线程的属性 (SIGEV_THREAD) */
    pid_t sigev_notify_thread_id; /* 要发送信号的线程ID (SIGEV_THREAD_ID); Linux特有的 */
};

---------------------------

 mq_notiy函数的使用注意事项：

a. 注册撤销：当通知被发送给它的注册进程时，其注册会被撤销。这意味着，如果希望继续接收通知，进程必须再次调用 mq_notify 以重新注册。

b. 空队列与数据到来：消息机制触发条件是，在消息队列为空的情况下有数据到来才会触发。当消息队列不为空时，即使有新的数据到来也不会触发通知。

c. 阻塞与通知：只有当没有任何线程阻塞在该队列的 mq_receive 调用的前提下，通知才会发出。这意味着，如果有线程正在等待接收消息，通知可能不会被发送。

----------------------------------------------------

取值

a. sigev_notify取值：

SIGEV_NONE：这个值表示不需要任何通知。当sigev_notify被设置为这个值时，即使事件发生了，也不会有任何通知发送到进程。

SIGEV_SIGNAL：事件发生时，将sigev_signo指定的信号发送给指定的进程；
SIGEV_THREAD：事件发生时，内核会（在此进程内）以sigev_notify_attributes为线程属性创建一个线程，并让其执行sigev_notify_function，并以sigev_value为其参数

b. sigev_signo:

在sigev_notify=SIGEV_SIGNAL时使用，指定信号类别, 例如SIGUSR1、SIGUSR2 等

c.sigev_value:

sigev_notify=SIGEV_SIGEV_THREAD时使用，作为sigev_notify_function的参数, 当发送
信号时,这个值会传递给信号处理函数。

实例：

基本使用case:

#include <mqueue.h>

#include <stdio.h>

#include <pthread.h>

#include <errno.h> //用于进行错误判断

#include <string.h>

#include <unistd.h>

#if 0

 

// mqd_t mq_open(const char *name, int oflag,mode_t mode, struct mq_attr attr );

// int mq_close(mqd_t mqdes);//

// int mq_unlink(const char *name);

// int mq_getattr(mqd_t mqdes, struct mq_attr *attr);

// int mq_setattr(mqd_t mqdes, struct mq_attr *attr,struct mq_attr *oattr);

// int mq_send(mqd_t mqdes, const char *ptr, size_tlen, unsigned int prio);

// ssize_t mq_receive(mqd_t mqdes, char *ptr, size_tlen, unsigned int *prio);

// int mq_notify(mqd_t mqdes, const struct sigevent*notification);

 

struct mq_attr

{

long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK

long mq_maxmsg;//最大消息数

long mq_msgsize;//每个消息最大大小

long mq_curmsgs;//当前消息数

};

#endif

#define QUEUE_NAME  "/test_queue" // 我们要创建的消息队列文件名

#define MESSAGE "mqueue,test!"

void *sender_thread(void* arg) //发送消息

{

   mqd_t mqd = *(mqd_t *)arg;

   char message[] = MESSAGE;

   int re_send=-1;

   printf("sender_thread:message = %s\nmqd = %d\n",message,mqd);

   re_send=mq_send(mqd,message,strlen(message)+1,0);

   if(-1 == re_send)

   {

      if(errno == EAGAIN)

      {

        printf("message queue is full\ns");

      }

      else

      {

        printf("mq_send");

      }

   }

  return NULL;

}

void *reciver_thread(void *arg) /// 接收消息

{

    mqd_t mqd = *(mqd_t *)arg;

    char buffer[256];

    printf("Recive thread start!\n");

    ssize_t re_recv= mq_receive(mqd,buffer,sizeof(buffer),NULL);

     printf("reciver_thread:buffer = %s\nmqd = %d\nre_recv = %ld\n",buffer,mqd,re_recv);

    return NULL;

}

int main(int argc, char **argv)

{

    //创建线程

    pthread_t sender, reciver;

    //创建消息队列

    mqd_t mqd=-1;

    struct mq_attr attr;

    attr.mq_flags=0;

    attr.mq_maxmsg=10;

    attr.mq_msgsize=256;

    attr.mq_curmsgs=0;

    // mqd_t mq_open(const char *name, int oflag,mode_t mode, struct mq_attr attr );

    // 打开文件 QUEUE_NAME,没有就创建，打开方式为可读可写，给到0666的权限

    mqd = mq_open(QUEUE_NAME,O_CREAT | O_RDWR,0666,&attr);

    if(mqd == (mqd_t)-1){

    perror("mq_open");

    return -1;

    }

    // 将mqd 作为参数传递给线程

    if (pthread_create(&sender, NULL, sender_thread, (void *)&mqd) != 0)

    {

       perror("pthread_create sender");

       return -1;

    }

    if (pthread_create(&reciver, NULL, reciver_thread,(void *)&mqd) != 0)

    {

        perror("pthread_create reciver");

        return -1;

    }

    // 等待线程退出

    pthread_join(sender, NULL);

    pthread_join(reciver, NULL);

    mq_close(mqd);  // 关闭 mqd 打开的文件

    mq_unlink(QUEUE_NAME);  // 删除 mqd 打开的文件

    return 0;

}

各种情况输出: 

发送接收

即上面代码的输出

  在SystemV 里用 ipcs 去看消息队列

在posix 里面使用以下命令查看:

cat /dev/mqueue/test_queue

unlinke 会执行如下命令:

rm  /dev/mqueue/test_queue

-------------------

加上延时观察

在发送 和 接收前都加上延时 sleep(20);

发现我们的 test_queue 这个文件先从不存在，到被创建，被写入13大小的数据，然后被删除

屏蔽unlink

if 我们把unlink 屏蔽掉，去执行，会发现执行完后我们的 test_mqueue 仍然存在

-----------------------
请记住我们队列最大的条数设置为10

---------

只发送 接收

发送十条消息

消息队列的文件大小一直在变化

可以看到发送到第十条 的时候产生了阻塞 不再能够发送
这是因为我们设置为了阻塞模式，如下

------------------

只接收不发送

接收十次

结果也是一样的进行了10次后阻塞在这里
达到最大消息数目

// 以上两个实例都展示了我们的最大接收消息数，和设置阻塞的作用

既不发送也不接收

------------------------

总结(一定要看)

通过如上的实例，相信你已经理解了
我们的mq_open() 去创建我们 /dev/mqueue/ 底下的 test_queue 这个消息队列文件，并指定消息队列为阻塞模式，最大消息数目为10

然后我们的发送消息: mq_send() -- 会对这个消息队列文件添加内容，size增加

mq_recive() 接收到消息后，就把其中的内容读取，size减少

我们的unlink控制  rm  /dev/mqueue/test_queue，将这个文件清除，每次都执行清除确保这个我们不会读到之前的消息

 

=============================

异步通知 ：mq_notify() 的用法:

通过异步通知的方式实现接收，并不是多开一个接收线程

----------------------------------------

#include <mqueue.h>
#include <stdio.h>
#include <pthread.h>
#include <errno.h> //用于进行错误判断 
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>

#if 0

// mqd_t mq_open(const char *name, int oflag,mode_t mode, struct mq_attr attr );
// int mq_close(mqd_t mqdes);//
// int mq_unlink(const char *name);
// int mq_getattr(mqd_t mqdes, struct mq_attr *attr);
// int mq_setattr(mqd_t mqdes, struct mq_attr *attr,struct mq_attr *oattr);
// int mq_send(mqd_t mqdes, const char *ptr, size_tlen, unsigned int prio);
// ssize_t mq_receive(mqd_t mqdes, char *ptr, size_tlen, unsigned int *prio);
// int mq_notify(mqd_t mqdes, const struct sigevent*notification);

struct mq_attr
{
long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK
long mq_maxmsg;//最大消息数
long mq_msgsize;//每个消息最大大小
long mq_curmsgs;//当前消息数
};

union sigval { /* 传递给通知的数据 */
    int sival_int;       /* 整型值 */
    void *sival_ptr;     /* 指针值 */
};

struct sigevent {
    int sigev_notify;    /* 通知方式 */
    int sigev_signo;     /* 通知信号 */
    union sigval sigev_value; /* 传递给通知的数据 */
    void (*sigev_notify_function) (union sigval); /* 线程通知使用的函数 (SIGEV_THREAD) */
    void *sigev_notify_attributes; /* 通知线程的属性 (SIGEV_THREAD) */
    pid_t sigev_notify_thread_id; /* 要发送信号的线程ID (SIGEV_THREAD_ID); Linux特有的 */
};

#endif

#define QUEUE_NAME  "/test_queue"
#define MESSAGE "mqueue,test!"

void *sender_thread(void* arg) //发送消息
{
   mqd_t mqd = *(mqd_t *)arg;
   char message[] = MESSAGE;
   int re_send=-1;
   printf("sender_thread:message = %s\nmqd = %d\n",message,mqd);
   re_send=mq_send(mqd,message,strlen(message)+1,0);
   if(-1 == re_send)
   {
      if(errno == EAGAIN)
      {
        printf("message queue is full\ns");
      }

      else
      {
        printf("mq_send");
      }

   }

  return NULL;
}

void notify_thread(union sigval arg)
{
   mqd_t mqd = -1;
   mqd = *(mqd_t *)arg.sival_ptr;
   char buffer[256];
   ssize_t re_recv = -1;

   
   memset(buffer,0,sizeof(buffer));
   printf("notify_thread start: mqd = %d\n",mqd);
   re_recv = mq_receive(mqd,buffer,sizeof(buffer),NULL);
   printf("notify_thread:re_recv = %ld\n,buffer = %s\n",re_recv,buffer);

    if(-1 == re_recv)
    {
      if(errno == EAGAIN)
      {
        printf("message queue is empty\n");
         exit(1);
      }
      else
      {
        printf("mq_receive");
        exit(1);
      }
    }

 //a. 注册撤销：当通知被发送给它的注册进程时，其注册会被撤销。这意味着，如果希望

 //继续接收通知，进程必须再次调用 mq_notify 以重新注册。

    struct sigevent sev;
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = notify_thread;
    sev.sigev_notify_attributes = NULL;
    sev.sigev_value.sival_ptr = &mqd;
  // 重新注册:
  if(mq_notify(mqd,&sev) == -1)
  {
    perror("mq_notify");
    exit(1);
  }
}

int main(int argc, char **argv)
{
    //创建线程
    pthread_t sender;
    //创建消息队列
    mqd_t mqd=-1;

    struct mq_attr attr;
    attr.mq_flags=0;
    attr.mq_maxmsg=10;
    attr.mq_msgsize=256;
    attr.mq_curmsgs=0;
    // mqd_t mq_open(const char *name, int oflag,mode_t mode, struct mq_attr attr );
    // 打开文件 QUEUE_NAME,没有就创建，打开方式为可读可写，给到0666的权限
    mqd = mq_open(QUEUE_NAME,O_CREAT | O_RDWR,0666,&attr);
    if(mqd == (mqd_t)-1){
    perror("mq_open");
    return -1;
    }
    struct sigevent sev;
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = notify_thread;
    sev.sigev_notify_attributes = NULL;
    sev.sigev_value.sival_ptr = &mqd;
    
      // 注册:
    if(mq_notify(mqd,&sev) == -1)
    {
      perror("mq_notify");
      exit(1);
    }

   

    // 将mqd 作为参数传递给线程
    if (pthread_create(&sender, NULL, sender_thread, (void *)&mqd) != 0)
    {
       perror("pthread_create sender");
       return -1;
    }

    // 等待线程退出
    pthread_join(sender, NULL);
    sleep(5); // 等待信号被接收，再删除消息队列文件，防止访问不到这个文件
    mq_close(mqd);  // 关闭 mqd 打开的文件
    mq_unlink(QUEUE_NAME);  // 删除 mqd 打开的文件

    return 0;
}

结果输出