POSIX消息队列
1.主要函数
创建或打开消息队列
mqd_t mq_open(const char *name,int oflag,mode_t mode,struct mq_attr *attr);
函数来创建或打开一个消息队列。该函数接受队列名称、打开标志以及可选的权限和属性作为参数。如果队列不存在且指定了创建标志，将会创建一个新的消息队列。成功创建或打开后，函数返回一个消息队列描述符（mqd_t）。
发送消息
int mq_send(mqd_t mqdes,const char *msg_ptr,size_t msg_len,unsigned int msg_prio);
函数来发送一个消息到指定的消息队列。该函数接受消息队列描述符、指向消息的指针以及消息的大小作为参数。发送消息时，可以指定消息的优先级，较高的优先级数值表示较高的优先级。成功发送后，函数返回0，否则返回-1并设置errno来表示错误原因。
接收信息
ssize_t mq_receive(mqd_t mqdes, char *mdg_ptr,size_t msg_len,unsigned int *msg_prio);
函数来从指定的消息队列中接收一个消息。该函数接受消息队列描述符、指向接收缓冲区的指针以及缓冲区的最大大小作为参数。接收消息时，可以选择按优先级接收，也可以选择非阻塞接收。成功接收后，函数返回接收到的消息的大小，否则返回-1并设置errno来表示错误原因。
关闭消息队列
int mq_close(mqd_t mqdes);
函数来关闭一个已打开的消息队列。该函数接受消息队列描述符作为参数。关闭消息队列后，相关的资源将被释放。
删除消息队列
int mq_unlink(const char *name);
函数来删除一个已存在的消息队列。该函数接受队列名称作为参数。删除一个消息队列将会移除与之关联的所有消息和状态.**
异步通知
设置异步通知
int mq_notify(mqd_t mqdes,const struct sigevent *notification);
函数来
注册一个进程以接收异步通知。该函数接受消息队列描述符、一个指向sigevent结构的指针以及一个通知标志作为参数。在sigevent结构中，可以设置当消息到达时要发送的信号或者要调用的回调函数。通过设置用int mq_notify(mqd_t mqdes,const struct sigevent *notification);，当消息队列从空变为非空时，已注册的进程将收到一个信号或触发一个回调函数，以异步地通知该进程。
其余函数一样
其他说明:
- 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属性结构提：
struct mq_attr
{
long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK
long mq_maxmsg;//最大消息数
long mq_msgsize;//每个消息最大大小
long mq_curmsgs;//当前消息数
};
- mq_notiy函数的使用注意事项：
a. 注册撤销：当通知被发送给它的注册进程时，其注册会被撤销。这意味着，如果希望继续接收通知，
进程必须再次调用 mq_notify 以重新注册。
b. 空队列与数据到来：消息机制触发条件是，在消息队列为空的情况下有数据到来才会触发。当消息队
列不为空时，即使有新的数据到来也不会触发通知。
c. 阻塞与通知：只有当没有任何线程阻塞在该队列的 mq_receive 调用的前提下，通知才会发出。这意
味着，如果有线程正在等待接收消息，通知可能不会被发送。
- struct sigevent和sigval_t sigev_val 的定义如下：
union sigval { /* Data passed with notification */
int sival_int; /* Integer value */
void *sival_ptr; /* Pointer value */
};
struct sigevent {
int sigev_notify; /* Notification method */
int sigev_signo; /* Notification signal */
union sigval sigev_value;
/* Data passed with notification */
void (*sigev_notify_function) (union sigval);
/* Function used for thread
notification (SIGEV_THREAD) */
void *sigev_notify_attributes;
/* Attributes for notification thread
(SIGEV_THREAD) */
pid_t sigev_notify_thread_id;
/* ID of thread to signal
(SIGEV_THREAD_ID); Linux-specific */
};
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的参数, 当发送
信号时,这个值会传递给信号处理函数。
示例1:使用阻塞方式读写
方式一:全局变量
#include <pthread.h> // POSIX线程库
#include <stdio.h> // 标准输入输出库
#include <stdlib.h> // 标准库
#include <unistd.h> // UNIX标准库
#include <mqueue.h> // POSIX消息队列库
#include <string.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_send(mqd_t mqdes, const char *ptr, size_t len, unsigned int prio);
ssize_t mq_receive(mqd_t mqdes, char *ptr, size_t len, unsigned int *prio);
struct mq_attr
{
long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK
long mq_maxmsg;//最大消息数
long mq_msgsize;//每个消息最大大小
long mq_curmsgs;//当前消息数
};
*/
#define QUEUE_NAME "/test_queue"
#define MESSAGE "Hello,world"
mqd_t mq;
//发送消息
void* sender_thread(void *arg)
{
int ret=0;
printf("sender thread started\n");
ret=mq_send(mq,MESSAGE,strlen(MESSAGE)+1,0);
if(ret==-1)
{
printf("send failed\n");
}
printf("messsage sent\n");
return NULL;
}
//接收消息
void* reveier_thread(void *arg)
{
char buffer[256]={0};
ssize_t ret=0;
printf("receive thread started\n");
ret=mq_receive(mq,buffer,sizeof(buffer),NULL);
if(ret==-1)
{
printf("reveier failed\n");
}
printf("reveier message:%s\n",buffer);
return NULL;
}
int main()
{
pthread_t sender,reveier;
struct mq_attr attr;
attr.mq_flags=0;
attr.mq_maxmsg=10;
attr.mq_msgsize=256;
attr.mq_curmsgs=0;
mq=mq_open(QUEUE_NAME,O_CREAT|O_RDWR,0666,attr);
if(mq==-1)
{
perror("mq_open");
return -1;
}
if(pthread_create(&sender,NULL,sender_thread,NULL)!=0)
{
perror("send");
return -1;
}
if(pthread_create(&reveier,NULL,reveier_thread,NULL)!=0)
{
perror("send");
return -1;
}
pthread_join(sender,NULL);
pthread_join(reveier,NULL);
mq_close(mq);
mq_unlink(QUEUE_NAME);
return 0;
}
方式二:线程传参
#include<mqueue.h>
#include<pthread.h>
#include<string.h>
#include<stdio.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_send(mqd_t mqdes, const char *ptr, size_t
len, unsigned int prio);
ssize_t mq_receive(mqd_t mqdes, char *ptr, size_t
len, unsigned int *prio);
struct mq_attr
{
long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK
long mq_maxmsg;//最大消息数
long mq_msgsize;//每个消息最大大小
long mq_curmsgs;//当前消息数
};
*/
#define QUEUE_NAME "/test_queue"
#define MESSAGE "Hello,world"
//发送信息
void *sender_thread(void* arg)
{
mqd_t mq=*(mqd_t*)arg;
int size_t=0;
printf("send thread started\n");
size_t=mq_send(mq,MESSAGE,strlen(MESSAGE)+1,0);
if(size_t==-1)
{
printf("send failed\n");
}
printf("msg sent.....\n");
return NULL;
}
//接收消息
void *receiver_thread(void* arg)
{
mqd_t mq=*(mqd_t*)arg;
char buffer[256]={0};
ssize_t size_t=0;
printf("revice thread started\n");
size_t=mq_receive(mq,buffer,sizeof(buffer),NULL);
if(size_t==-1)
{
printf("recevice failed\n");
}
printf("revicer msg:%s\n",buffer);
return NULL;
}
int main()
{
pthread_t sender,receiver;
mqd_t mq;
struct mq_attr attr;
attr.mq_flags=0;
attr.mq_maxmsg=10;
attr.mq_msgsize=256;
attr.mq_curmsgs=0;
mq=mq_open(QUEUE_NAME,O_CREAT|O_RDWR,0666,&attr);
if(mq==-1)
{
perror("mq_open");
return -1;
}
if(pthread_create(&sender,NULL,sender_thread,(void*)&mq)!=0)
{
perror("sender");
return -1;
}
if(pthread_create(&receiver,NULL,receiver_thread,(void*)&mq)!=0)
{
perror("sender");
return -1;
}
pthread_join(sender,NULL);
pthread_join(receiver,NULL);
mq_close(mq);
mq_unlink(QUEUE_NAME);
return 0;
}
使用mq_notify sigev_notify = SIGEV_THREAD异步通知的方式实现
#include <mqueue.h>
#include <pthread.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#if 0
mqd_t mq_open(const char *name, int oflag, mode_t mode, struct mq_attr attr );
int mq_send(mqd_t mqdes, const char *ptr, size_t len, unsigned int prio); /tiemou
ssize_t mq_receive(mqd_t mqdes, char *ptr, size_t len, unsigned int *prio);
int mq_close(mqd_t mqdes);
int mq_unlink(const char *name)
struct mq_attr
{
long mq_flags;//阻塞标志， 0(阻塞)或O_NONBLOCK
long mq_maxmsg;//最大消息数
long mq_msgsize;//每个消息最大大小
long mq_curmsgs;//当前消息数
};
union sigval { /* Data passed with notification */
int sival_int; /* Integer value */
void *sival_ptr; /* Pointer value */
};
struct sigevent {
int sigev_notify; /* Notification method */
int sigev_signo; /* Notification signal */
union sigval sigev_value;
/* Data passed with notification */
void (*sigev_notify_function) (union sigval);
/* Function used for thread
notification (SIGEV_THREAD) */
void *sigev_notify_attributes;
/* Attributes for notification thread
(SIGEV_THREAD) */
pid_t sigev_notify_thread_id;
/* ID of thread to signal
(SIGEV_THREAD_ID); Linux-specific */
};
#endif
#define QUEQUE_NAME "/test_queue"
#define MESSAGE "Hello,world"
void *sender_thread(void *arg)
{
// 发送消息
mqd_t mqd = *(mqd_t *)arg;
int send_size = -1;
char message[] = MESSAGE;
printf("sender thread message=%s, mqd=%d\n", message, mqd);
send_size = mq_send(mqd, message, strlen(message) + 1, 0);
if (-1 == send_size)
{
if (errno == EAGAIN)
{
printf("message queque is full\n");
}
else
{
perror("mq_send");
}
}
return NULL;
}
void notify_thread (union sigval sval)
{
// 获取消息队列描述符
mqd_t mqd = -1;
mqd = *((mqd_t *)sval.sival_ptr);
// 定义一个缓冲区，用于存储接收到的消息
char buffer[256];
// 定义一个变量，用于存储接收到的消息的大小
ssize_t bytes_read;
// 定义一个结构体，用于重新注册消息队列的通知
struct sigevent sev;
// 打印提示信息
printf("notify_thread started, mqd=%d\n", mqd);
// 循环接收消息，直到队列为空
while (1)
{
// 从消息队列中接收消息
bytes_read = mq_receive(mqd, buffer, 256, NULL);
// 如果接收失败，检查错误码
if (bytes_read == -1)
{
// 如果错误码是EAGAIN，说明队列为空，跳出循环
if (errno == EAGAIN)
{
printf("queue is empty\n");
break;
}
// 否则，打印错误信息，退出程序
else
{
perror("mq_receive");
exit(1);
}
}
// 如果接收成功，打印接收到的消息的大小和内容
printf("read %ld bytes: %s\n", (long)bytes_read, buffer);
}
// 重新注册消息队列的通知，使用同样的回调函数和参数
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, receiver;
//创建消息队列
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 = mq_open(QUEQUE_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);
}
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);
mq_unlink(QUEQUE_NAME);
return 0;
}
431
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
