系统编程-进程间通信

进程间通信

概念

进程间通信（IPC）是指在不同进程之间传递信息的机制。由于进程的用户空间是独立的，它们不能直接访问彼此的内存空间，因此需要通过一些特定的IPC机制来交换数据。进程间通信的本质，就是让两个进程能够看到同一份“资源”，这份资源一般由操作系统提供，因此，进程访问这份资源进行通信，本质上就是在访问操作系统，所以要实现进程间通信，我们需要调用对应的系统调用接口。

通信方式

管道
内存映射
消息队列

管道

管道是Unix中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的数据流称为一个“管道”
可以把管道想象成连接两个进程间的一条管子，一个进程的数据流就能通过这个管子流向另一个进程。
管道分为匿名管道和命名管道，它们都是通过内核的一块缓冲区实现数据传输
管道文件实际上不是一个磁盘文件，是一个内存文件

匿名管道

匿名管道用于进程间通信，只能用于具有共同祖先的进程（具有亲缘关系的进程）之间的通信。
使用匿名管道实现父子进程间通信的原理就是，让两个父子进程先看到同一份被打开的文件资源，然后父子进程就可以对该文件进行写入或是读取操作，进而实现父子进程间通信。

创建匿名管道

pipe()函数

函数描述：

        创建匿名管道

函数原型：

        int pipe(int pipefd[2]);

函数参数：

        pipefd是一个传出参数，用于返回两个指向管道读端和写端的文件描述符：

        pipefd[0]：管道读端的文件描述符

        pipefd[1]：管道写端的文件描述符

        为什么要用两个文件描述符？因为文件偏移量会共享。

函数返回值：

        成功返回0

        失败返回-1，设置errno

创建过程

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pipefd[2];
    int ret = pipe(pipefd);
    printf("ret = %d\n", ret);

    int pip = fork();
    if(pip == 0)  //子进程写数据，关闭读端
    {
        close(pipefd[0]);
        int write_count = write(pipefd[1], "hello", 5);
        printf("write_count = %d\n", write_count);
    }
    else  //父进程读数据，关闭写端
    {
        sleep(5);
        close(pipefd[1]);
        char buf[64];
        int read_count = read(pipefd[0], buf, sizeof(buf));
        printf("read_count = %d\n", read_count);
        if(read_count > 0)
        {
            printf("buf = %s\n", buf);
        }
    }

    return 0;
}

注意：管道只能够进行单向通信（半双工），因此当父进程创建完子进程后，需要确认父子进程谁读谁写，然后关闭相应的读写端

匿名管道的特性

（1）管道的读端和写端的文件描述符不会相互影响

（2）管道有阻塞等待的功能

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pipefd[2];
    int ret = pipe(pipefd);
    printf("ret = %d\n", ret);

    int pip = fork();
    if(pip == 0)  //子进程写数据，关闭读端
    {
        sleep(5);  //先读后写也能够读到，因为pipe()会阻塞等待
        close(pipefd[0]);
        int write_count = write(pipefd[1], "hello", 5);
        printf("write_count = %d\n", write_count);
    }
    else  //父进程读数据，关闭写端
    {
        close(pipefd[1]);
        char buf[64];
        int read_count = read(pipefd[0], buf, sizeof(buf));
        printf("read_count = %d\n", read_count);
        if(read_count > 0)
        {
            printf("buf = %s\n", buf);
        }
    }

    return 0;
}

（3）管道中的数据被读出后，就会从管道中移出

管道中没有数据：write 返回成功写入的字节数，读端进程阻塞在 read 上
管道中有数据但是没满：write 返回成功写入的字节数，read 返回成功读取的字节数
管道已满：写端进程阻塞在 write 上，read 返回成功读取的字节数（当读出的数据够多，即清理出的内存够大时，写端会继续写，读端会继续读）

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pipefd[2]; 
    int ret = pipe(pipefd); 
    printf("ret = %d\n", ret);
   
    int pid = fork(); 
    if (pid == 0)  //子进程写数据，关闭读端
    {
        close(pipefd[0]);
        while (1)  //不断写入数据
        {
            int write_count = write(pipefd[1], "hello", 5);
            printf("write count = %d\n", write_count);
        }
    }
    else  //父进程读数据，关闭写端
    {   
        close(pipefd[1]);
        char buf[64];   // char buf[4096]; // 多清理一些之后会继续读（缓冲区）
        int read_count = read(pipefd[0], buf, sizeof(buf));  
        printf("read count = %d\n", read_count);   
        if (read_count > 0) 
        {             
            printf("buf: %s\n", buf);     
        }
    }
    while (1);

    return 0;
}

（4）写端全部关闭：read正常读，返回读到的字节数（管道中没有数据返回0，不阻塞）

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pipefd[2];
    int ret = pipe(pipefd);
    printf("ret = %d\n", ret);

    int pip = fork();
    if(pip == 0)  //子进程，关闭读端和写端
    {
        close(pipefd[0]);
        close(pipefd[1]);
        int write_count = write(pipefd[1], "hello", 5);
        printf("write_count = %d\n", write_count);
    }
    else  //父进程读数据，关闭写端
    {
        sleep(5);
        close(pipefd[1]);
        char buf[64];
        int read_count = read(pipefd[0], buf, sizeof(buf));
        printf("read_count = %d\n", read_count);
        if(read_count > 0)
        {
            printf("buf = %s\n", buf);
        }
    }

    return 0;
}

（5）读端全部关闭：写端进程write会异常终止进程

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pipefd[2];
    int ret = pipe(pipefd);
    printf("ret = %d\n", ret);

    int pip = fork();
    if(pip == 0)  //子进程写数据，关闭读端
    {
        close(pipefd[0]);
        int write_count = write(pipefd[1], "hello", 5);
        printf("write_count = %d\n", write_count);
    }
    else  //父进程，关闭读端和写端
    {
        sleep(5);
        close(pipefd[0]);
        close(pipefd[1]);
        char buf[64];
        int read_count = read(pipefd[0], buf, sizeof(buf));
        printf("read_count = %d\n", read_count);
        if(read_count > 0)
        {
            printf("buf = %s\n", buf);
        }
    }

    return 0;
}

练习

使用管道实现ls / | wc -l

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pipefd[2];
    int ret = pipe(pipefd);
    printf("ret = %d\n", ret);

    int pip = fork();
    if(pip == 0)
    {
        close(pipefd[0]);
        dup2(pipefd[1], 1);
        execlp("ls", "ls", "/", NULL);
    }
    else
    {
        close(pipefd[1]);
        dup2(pipefd[0], 0);
        execlp("wc", "wc", "-l", NULL);
    }

    return 0;
}

命名管道

命名管道就是一种特殊类型的文件，两个进程通过命名管道的文件名打开同一个管道文件，此时这两个进程也就看到了同一份资源，进而就可以进行通信了。
命名管道和匿名管道一样，都是内存文件，只不过命名管道在磁盘有一个简单的映像，但这个映像的大小永远为0，因为命名管道和匿名管道都不会将通信数据刷新到磁盘当中。

创建命名管道

mkfifo 命令

mkfifo fifo

mkfifo()函数

函数描述：

        程序中创建命名管道

头文件：

        #include<sys/types.h>

        #include<sys/stat.h>

函数原型：

        int mkfifo(const char *pathname, mode_t mode);

函数参数：

        pathname：表示要创建的命名管道文件

        mode：表示创建命名管道文件的默认权限

函数返回值：

        成功，返回0

        失败，返回-1

（1）命名管道在父子进程间通信：

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int ret = mkfifo("./fifo", 0664);  //创建管道文件
    int fd = open("fifo", O_RDWR);  //打开管道文件
    
    int pid = fork();
    if(pid == 0)
    {
        write(fd, "hello", 5);
    }
    else
    {
        char buf[64];
        int read_count = read(fd, buf , sizeof(buf));
        printf("read_count = %d\n", read_count);
    }
    
    return 0;
}

（2）命名管道在没有血缘关系的进程间通信：

wfifo.c（写进程）

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_RDONLY);
    write(fd, "hello", 5);
    
    return 0;
}

rfifo.c（读进程）

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    //printf("open\n");
    int fd = open("./fifo", O_RDONLY);
    //printf("read\n);
    char buf[1024];
    int ret = read(fd, buf, sizeof(buf));
    printf("read count = %d, buf = %s\n", ret, buf);
    
    return 0;
}

上述代码直接运行 wfifo，会阻塞在 open 处，当 rfifo 中的 open 执行后，wfifo 才会继续运行（可以加上打印语句进行验证）

命名管道的特性

命名管道的打开规则：

读进程打开 FIFO，并且没有写进程打开时：

没有 O_NONBLOCK：阻塞直到有写进程打开 FIFO
有 O_NONBLOCK：直接返回成功

写进程打开 FIFO，并且没有读进程打开时：

没有 O_NONBLOCK：阻塞直到有读进程打开 FIFO
有 O_NONBLOCK：直接返回失败（fd 为 -1，以非阻塞方式打开管道文件就打开不了）

练习

两个程序使用fifo互发消息聊天

1.单向发送和接收固定的一条消息

wfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_WRONLY);
    write(fd, "hello", 5);
    
    return 0;
}

rfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_RDONLY);
    char buf[64];
    int read_count = read(fd, buf, sizeof(buf));
    printf("read_count = %d\nbuf = %s\n", read_count, buf);
    
    return 0;
}

2.单向发送和接收终端输入的一条消息

wfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_WRONLY);
    char buf[64];
    int read_count = read(0, buf, sizeof(buf));
    write(fd, buf, read_count);
    
    return 0;
}

rfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_RDONLY);
    char buf[64];
    int read_count = read(fd, buf, sizeof(buf));
    printf("read_count = %d\nbuf = %s\n", read_count, buf);
    
    return 0;
}

3.单向循环发送和接收终端输入的消息

wfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_WRONLY);
    char buf[64];
    while(1)
    {
        int read_count = read(0, buf, sizeof(buf));
        write(fd, buf, read_count);
    }
   
    return 0;
}

rfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int fd = open("fifo", O_RDONLY);
    char buf[64];
    while(1)
    {
        int read_count = read(fd, buf, sizeof(buf));
        write(1, buf, read_count);
        //buf[read_count] = '\0';
        //printf("read_count = %d\nbuf = %s\n", read_count, buf);
    }

    return 0;
}

4.双向循环发送和接收终端输入的消息

wfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pid = fork();
    if(pid == 0)
    {
        int write_fd = open("fifo1", O_WRONLY);
        char buf[64];
        while(1)
        {
            int read_count = read(0, buf, sizeof(buf));
            write(write_fd, buf, read_count);
        }
    }
    else
    {
        int read_fd = open("fifo2", O_RDONLY);
        char buf[64];
        while(1)
        {
            int read_count = read(read_fd, buf, sizeof(buf));
            write(1, buf, read_count);
        }
    }
    
    return 0;
}

rfifo.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char* argv[])
{
    int pid = fork();
    if(pid == 0)
    {
        int write_fd = open("fifo2", O_WRONLY);
        char buf[64];
        while(1)
        {
            int read_count = read(0, buf, sizeof(buf));
            write(write_fd, buf, read_count);
        }
    }
    else
    {
        int read_fd = open("fifo1", O_RDONLY);
        char buf[64];
        while(1)
        {
            int read_count = read(read_fd, buf, sizeof(buf));
            write(1, buf, read_count);
        }
    }
    
    return 0;
}

内存映射

内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。
映射分为两种：

1、文件映射：将文件的一部分映射到调用进程的虚拟内存中。对文件映射部分的访问转化为对相应内存区域的字节操作。映射页面会按需自动从文件中加载。

2、匿名映射：一个匿名映射没有对应的文件。其映射页面的内容会被初始化为 0。

mmap() 函数

函数描述：

        在调用进程的虚拟地址空间中创建一个新内存映射

头文件：

        #include<sys/stat.h>

函数原型：

        void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

函数参数：

        addr：指向欲映射的内存起始地址，通常设为 NULL，代表系统自动选定地址

        length：映射的长度。

        prot：映射区域的保护方式：

                PROT_READ：映射区域可读取

                PROT_WRITE：映射区域可修改

        flags：影响映射区域的特性。必须指定MAP_SHARED 或MAP_PRIVATE

                MAP_SHARED：创建共享映射。对映射的写入会写入文件里，其他共享映射的进程可见

                MAP_PRIVATE：创建私有映射。对映射的写入不会写入文件里，其他映射进程不可见

                MAP_ANONYMOUS：创建匿名映射。此时会忽略参数fd（设为-1），不涉及文件，没有血缘关系的进程不能共享

        fd：要映射的文件描述符，匿名映射设为-1

        offset：文件映射的偏移量，通常设置为0，代表从文件最前方开始对应，offset必须是分页大小（4k）的整数倍

函数返回值：

        若映射成功则返回映射区的内存起始地址，否则返回MAP_FAILED(-1)，错误原因存于errno 中

munmap()函数

函数描述：

        解除映射区域

头文件：

        #include <sys/mman.h>

函数原型：

        int munmap(void *addr, size_t length);

函数参数：

        addr：指向要解除映射的内存起始地址

        length：解除映射的长度

函数返回值：

        成功返回0，失败返回-1，错误原因存于errno 中

匿名映射

匿名映射用于进程间通信，只能用于具有共同祖先的进程（具有亲缘关系的进程）之间的通信

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>

int main(int argc, char* argv[])
{
    char *ptr = (char*)mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    int pip = fork();
    if(pip == 0)
    {
        strcpy(ptr, "hello");
        printf("child: ptr = %s\n", ptr);
    }
    else
    {
        sleep(1);
        printf("parent: ptr = %s\n", ptr);
    }
    
    int ret = munmap(ptr, 1024);  //解除映射
    printf("ret = %d\n", ret);

    return 0;
}

文件映射

文件映射用于任意两个进程间通信

wmman.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>

int main(int argc, char* argv[])
{
    int fd = open("./mman.txt", O_RDWR | O_CREAT | O_TRUNC , 0664);
    ftruncate(fd, 1024);  //扩容函数
    char *ptr = (char*)mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr == MAP_FAILED)
    {
        printf("mmap error\n");
        return 1;
    }

    int i = 0;
    while(1)
    {
        sprintf(ptr, "--%d--", i++);  //将i++的值打印到ptr中
        sleep(1);
    }

    return 0;
}

注：新创建的文件大小为0，要对其进行扩容，否则它的映射大小为0，相当于没有映射，会报“总线错误”

rmman.c

#include <stdio.h>
#include <string.h>                                                              
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>

int main(int argc, char* argv[])
{
    int fd = open("./mman.txt", O_RDONLY);
    char *ptr = (char*)mmap(NULL, 1024, PROT_READ, MAP_SHARED, fd, 0);
    if(ptr == MAP_FAILED)
    {
        printf("mmap error\n");
        return 1;
    }

    int i = 0;
    while(1)
    {
        printf("ptr = %s\n", ptr);
        sleep(1);
    }

    return 0;
}

上述两个程序：

如果先结束 wmman，那么会一直打印 wmman 结束时的 i 值
如果先结束 rmman，那么还会不停地将 i++ 的值打印到 ptr 中，不会影响 wmman 程序的运行

消息队列

消息队列是保存在内核中的消息链表，消息队列是面向消息进行通信的，一次读取一条完整的消息，每条消息中还包含一个整数表示优先级，可以根据优先级读取消息。
进程A可以往队列中写入消息，进程B读取消息。并且，进程A写入消息后就可以终止，进程B在需要的时候再去读取。
每条消息通常具有以下属性：

                一个表示优先级的整数

                消息数据部分的长度

                消息数据本身

消息队列函数

头文件：

#include <fcntl.h>

#include <sys/stat.h>

#include <mqueue.h>

打开和关闭消息队列：

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

获取和设置消息队列属性：

int mq_getattr(mqd_t mqdes, struct mq_attr *attr);
int mq_setattr(mqd_t mqdes, const struct mq_attr *newattr, struct mq_attr *oldattr);

在队列中写入和读取一条消息：

int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio);
ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio); //最后一个是指针代表传出参数，地址

删除消息队列名：

int mq_unlink(const char *name);

注：标记删除，即如果有进程正在使用要删除的消息队列，那么该进程可以继续使用，等到没有进程使用时再删除

函数参数和返回值：

name：消息队列名

oflag：打开方式，类似open函数。

必选项：O_RDONLY，O_WRONLY，O_RDWR

可选项：O_NONBLOCK，O_CREAT，O_EXCL

mode：访问权限，oflag中含有O_CREAT且消息队列不存在时提供该参数

attr：队列属性，open时传NULL表示默认属性

mqdes：表示消息队列描述符

msg_ptr：指向缓冲区的指针

msg_len：缓冲区大小

msg_prio：消息优先级

返回值：

成功返回0，open返回消息队列描述符，mq_receive返回写入成功字节数

失败返回-1

注意：

需要使用GCC编译，还需要加上编译选项 -lrt

消息队列的关闭与删除

使用mq_close函数关闭消息队列，关闭后消息队列并不从系统中删除。一个进程结束，会自动调用关闭打开着的消息队列。
使用mq_unlink函数删除一个消息队列名，使当前进程无法使用该消息队列。并将队列标记为在所有进程关闭该队列后删除该队列。

消息队列属性

每个消息队列有四个属性：

long mq_flags; //是否阻塞
long mq_maxmsg; //最大消息数
long mq_msgsize; //最大消息大小
long mq_curmsgs; //当前消息的个数

mq_getattr：返回所有这些属性

mq_setattr：只能设置mq_flags属性，其他成员忽略，每个队列的最大消息数和每个消息的最大字节数只能在创建队列的时候设置，队列中当前的消息数只能获取不能设置

mq_open：可以指定 mq_maxmsg 和 mq_msgsize 属性，其他成员忽略

使用消息队列通信

wmsg.c

#include <stdio.h>
#include <string.h>                                                            
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <mqueue.h>


int main(int argc, char* argv[])
{
    mqd_t mqd = mq_open("/mymsg", O_RDWR | O_CREAT, 0664, NULL);
    if(mqd == -1)
    {
        printf("open error");
        return -1;
    }

    int ret = mq_send(mqd, argv[1], strlen(argv[1])+1, atoi(argv[2]));
    if(ret == -1)
    {
        printf("send error");
        return -1;
    }
    
    return 0;
}

rmsg.c

#include <stdio.h>
#include <string.h>                                                            
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <mqueue.h>


int main(int argc, char* argv[])
{
    mqd_t mqd = mq_open("/mymsg", O_RDONLY );
    if(mqd == -1)
    {
        printf("open error");
        return -1;
    }

    char buf[8192];  //单条消息的最大长度为8192，要设置为8192才能保证每条消息都能读到
    unsigned int prio;
    int ret = mq_receive(mqd, buf, sizeof(buf), &prio);
    if(ret == -1)
    {
        printf("receive error");
        return -1;
    }
    printf("buf = %s prio = %d\n", buf, prio);

    return 0;
}

删除消息队列名：（使用时需要注意将wmsg.c中的O_CREAT属性删掉，要不然执行一次之后又会创建）

#include <stdio.h>
#include <string.h>                                                            
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <mqueue.h>


int main(int argc, char* argv[])
{
    int ret = mq_unlink("/mymsg");
    if (ret == -1) 
    {
        perror("unlink error");
        return 1;
    }

    return 0;
}

查看消息队列属性

#include <stdio.h>
#include <string.h>                                                            
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <mqueue.h>


int main(int argc, char* argv[])
{
    mqd_t mqd = mq_open("/mymsg", O_RDONLY);
    if (mqd == -1) 
    {
        perror("mq_open error");
        exit(1);
    }

    struct mq_attr attr;
    mq_getattr(mqd, &attr);
    printf("mq_flags = %lu\n", attr.mq_flags);
    printf("mq_maxmsg = %lu\n", attr.mq_maxmsg);
    printf("mq_msgsize = %lu\n", attr.mq_msgsize);
    printf("mq_curmsgs = %lu\n", attr.mq_curmsgs);
    // 在创建的时候传入结构体可以修改上面的值。

    return 0;
}

修改消息队列属性：

#include <stdio.h>
#include <string.h>                                                            
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <mqueue.h>


int main(int argc, char* argv[])
{
   struct mq_attr new_attr, old_attr;
    
    mqd_t mqd = mq_open("/mymsg", O_RDWR | O_CREAT, 0664, NULL);
    if (mqd == -1) 
    {
        perror("mq_open error");
        return 1;
    }

    mq_getattr(mqd, &old_attr);
    printf("mq_flags = %lu\n", old_attr.mq_flags);

    new_attr.mq_flags = O_NONBLOCK;  // 队列标志

    if (mq_setattr(mqd, &new_attr, &old_attr) == -1) 
    {
        perror("mq_setattr");
        return 1;
    }

    mq_getattr(mqd, &old_attr);
    printf("mq_flags = %lu\n", old_attr.mq_flags);

    return 0;
}