linux消息队列简析

消息队列提供了一种在两个进程之间(相同进程或不同进程)传递数据的简单且有效的方法，使用者不需要关心锁的问题。

函数介绍：

key_t ftok(const char *pathname, int proj_id);

此函数可生成供msgget,semget,shmget使用的键值。pathname和proj_id相同，则生成的key值相同

int msgget(key_t key, int msgflg);

创建或获取消息队列id

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

消息队列发送函数

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
                      int msgflg);

消息队列接收函数

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

控制消息队列

1. 查看消息队列限制

$ipcs -l

------ Messages Limits --------
max queues system wide = 988 -->最多创建消息队列数
max size of message (bytes) = 8192 -->默认单个消息最大字节数
default max size of queue (bytes) = 16384 (16K)-->默认最多存储字节数

2. 查看当前系统消息队列信息

$ipcs -u

------ Messages Status --------
allocated queues = 0
used headers = 0
used space = 0 bytes

示例代码：

msg_queue_snd.c:

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

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

#include "msg_queue.h"

int msg_id = -1;

int msg_queue_limit_test() //性能测试函数
{
    struct msqid_ds msq_ds;
    int ret = -1;
    int i = 0;
    int limit = 80;
    char buf[512] = "hello";
    msg_event_t msg;

    memset(&msq_ds, 0, sizeof(msq_ds));
    ret = msgctl(msg_id, IPC_STAT, &msq_ds);
    if (ret < 0)
    {
        printf("%s: msg get failed: %s\n", __FUNCTION__, strerror(errno));
        exit(1);
    }

    printf("msg_stime: %ld, msg_rtime: %ld, msg_ctime: %ld, msg_qnum: %ld,"
            "msg_qbytes:%ld\n",
            msq_ds.msg_stime, msq_ds.msg_rtime, msq_ds.msg_ctime, msq_ds.msg_qnum,
            msq_ds.msg_qbytes);

    memset(&msq_ds, 0, sizeof(msq_ds));
    msq_ds.msg_qbytes = 16384 * 2;

    ret = msgctl(msg_id, IPC_SET, &msq_ds);
    if (ret < 0)
    {
        printf("%s: msg set failed: %s\n", __FUNCTION__, strerror(errno));
        exit(1);
    }

    ret = msgctl(msg_id, IPC_STAT, &msq_ds);
    if (ret < 0)
    {
        printf("%s: msg get failed: %s\n", __FUNCTION__, strerror(errno));
        exit(1);
    }

    printf("2:msg_stime: %ld, msg_rtime: %ld, msg_ctime: %ld, msg_qnum: %ld,"
        "msg_qbytes:%ld\n",
        msq_ds.msg_stime, msq_ds.msg_rtime, msq_ds.msg_ctime, msq_ds.msg_qnum,
        msq_ds.msg_qbytes);

    msg.msg_type = 1;
    strcpy(msg.buf, buf);
    for (i = 0; i < limit; i++)
    {
        printf("i: %d\n", i);
        ret = msgsnd(msg_id, &msg, sizeof(msg) - sizeof(long int), IPC_NOWAIT);
        if (ret < 0)
        {
            printf("%s: msg send failed: %s\n", __FUNCTION__, strerror(errno));
            exit(1);
        }
    }
    return 0;
}

int main(int argc, char *argv[])
{
    int i = 0;
    key_t key = -1;
    char buf[32] = {0};
    msg_event_t msg;
    int ret = -1;
    struct msqid_ds msq_ds;

    for (i = 0; i < MSG_QUEUE_NUM; i++)
    {
        key = ftok(KEY_DIR, 0);
        printf("%s: key[%d]: %d\n", __FUNCTION__, i, key);
    }

    msg_id = msgget(key, IPC_CREAT | 0666);
    if (msg_id < 0)
    {
        printf("%s: msg get failed: %s\n", __FUNCTION__, strerror(errno));
        exit(1);
    }

    printf("%s: msg id:%d\n", __FUNCTION__, msg_id);

    memset(&msq_ds, 0, sizeof(msq_ds));
    ret = msgctl(msg_id, IPC_STAT, &msq_ds);
    if (ret < 0)
    {
        printf("%s: msg get failed: %s\n", __FUNCTION__, strerror(errno));
        exit(1);
    }

    printf("msg_stime: %ld, msg_rtime: %ld, msg_ctime: %ld, msg_qnum: %ld,"
            "msg_qbytes:%ld\n",
            msq_ds.msg_stime, msq_ds.msg_rtime, msq_ds.msg_ctime, msq_ds.msg_qnum,
            msq_ds.msg_qbytes);

    //msg_queue_limit_test();

    while (1)
    {
        memset(&msg, 0, sizeof(msg));
        ret = read(STDIN_FILENO, buf, sizeof(buf));
        if (ret <= 0)
        {
            printf("%s: read from stdin %s\n", __FUNCTION__, strerror(errno));
            break;
        }

        buf[ret - 1] = '\0';

        msg.msg_type = 1;
        strcpy(msg.buf, buf);
        ret = msgsnd(msg_id, &msg, sizeof(msg) - sizeof(long int), IPC_NOWAIT);
        if (ret < 0)
        {
            printf("%s: msg send failed: %s\n", __FUNCTION__, strerror(errno));
            exit(1);
        }

        if (0 == strcmp(buf, "exit"))
        {
            printf("msg snd exit\n");
            break;
        }
    } 

    return 0;
}

msg_queue_recv.c:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

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

#include "msg_queue.h"

int msg_id = -1;

int main(int argc, char *argv[])
{
    int i = 0;
    key_t key = -1;
    msg_event_t msg;
    int ret = -1;

    for (i = 0; i < MSG_QUEUE_NUM; i++)
    {
        key = ftok(KEY_DIR, 0);
        printf("%s: key[%d]: %d\n", __FUNCTION__, i, key);
    }

    msg_id = msgget(key, 0666);
    if (msg_id < 0)
    {
        printf("%s: msg get failed: %s\n", __FUNCTION__, strerror(errno));
        exit(1);
    }

    printf("%s: msg id:%d\n", __FUNCTION__, msg_id);

    while (1)
    {
        memset(&msg, 0, sizeof(msg));

        msg.msg_type = 0;

        ret = msgrcv(msg_id, &msg, sizeof(msg), 0, 0);
        if (ret < 0)
        {
            printf("%s: msg get failed: %s\n", __FUNCTION__, strerror(errno));
            exit(1);
        }
        printf("get msg: %s\n", msg.buf);
        if (0 == strcmp(msg.buf, "exit"))
        {
            printf("msg get exit\n");
            break;
        }
    }

    msgctl(msg_id, IPC_RMID, NULL);

    return 0;
}

msg_queue.h:
#ifndef __MSG_QUEUE_H__
#define __MSG_QUEUE_H__

#define KEY_DIR "/tmp"
#define MSG_QUEUE_NUM 1

typedef struct msg_event_s
{
    long int msg_type;

    char buf[512];
} msg_event_t;

#endif

Makefile:
all:
    gcc -o msg_snd msg_queue_snd.c -g
    gcc -o msg_recv msg_queue_recv.c -g
clean:
    rm msg_snd
    rm msg_recv

测试结果

1. 默认最多存储16384字节，以单个消息512字节计算，可以存储32个消息

msg_stime: 1491099133, msg_rtime: 1491099143, msg_ctime: 1491094456, msg_qnum: 0,msg_qbytes:16384
i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10
i: 11
i: 12
i: 13
i: 14
i: 15
i: 16
i: 17
i: 18
i: 19
i: 20
i: 21
i: 22
i: 23
i: 24
i: 25
i: 26
i: 27
i: 28
i: 29
i: 30
i: 31
i: 32
msg_queue_limit_test: msg send failed: Resource temporarily unavailable

2.更改最大存储字节数为16384*2，以单个消息512字节计算，可以存储64个消息

msg_stime: 1491100080, msg_rtime: 1491100132, msg_ctime: 1491100080, msg_qnum: 0,msg_qbytes:32768
2:msg_stime: 1491100080, msg_rtime: 1491100132, msg_ctime: 1491100140, msg_qnum: 0,msg_qbytes:32768
i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
i: 8
i: 9
i: 10
i: 11
i: 12
i: 13
i: 14
i: 15
i: 16
i: 17
i: 18
i: 19
i: 20
i: 21
i: 22
i: 23
i: 24
i: 25
i: 26
i: 27
i: 28
i: 29
i: 30
i: 31
i: 32
i: 33
i: 34
i: 35
i: 36
i: 37
i: 38
i: 39
i: 40
i: 41
i: 42
i: 43
i: 44
i: 45
i: 46
i: 47
i: 48
i: 49
i: 50
i: 51
i: 52
i: 53
i: 54
i: 55
i: 56
i: 57
i: 58
i: 59
i: 60
i: 61
i: 62
i: 63
i: 64
msg_queue_limit_test: msg send failed: Resource temporarily unavailable-->队列已满

3. 发送、接收测试

 $./msg_snd 
main: key[0]: 65538
main: msg id:98304
msg_stime: 1491100739, msg_rtime: 1491100747, msg_ctime: 1491100737, msg_qnum: 0,msg_qbytes:16384
hello
exit
msg snd exit

$./msg_recv 
main: key[0]: 65538
main: msg id:98304
get msg: hello
get msg: exit
msg get exit