操作系统实验——利用Linux的消息队列通信机制实现两个线程间的通信
目录
一. 题目描述
编写程序创建三个线程：sender1线程、sender2线程和receive线程，三个线程的功能描述如下：
①sender1线程：运行函数sender1()，它创建一个消息队列，然后等待用户通过终端输入一串字符，并将这串字符通过消息队列发送给receiver线程；可循环发送多个消息，直到用户输入“exit”为止，表示它不再发送消息，最后向receiver线程发送消息“end1”，并且等待receiver的应答，等到应答消息后，将接收到的应答信息显示在终端屏幕上，结束线程的运行。
②sender2线程：运行函数sender2()，共享sender1创建的消息队列，等待用户通过终端输入一串字符，并将这串字符通过消息队列发送给receiver线程；可循环发送多个消息，直到用户输入“exit”为止，表示它不再发送消息，最后向receiver线程发送消息“end2”，并且等待receiver的应答，等到应答消息后，将接收到的应答信息显示在终端屏幕上，结束线程的运行。
③Receiver线程：运行函数receive()，它通过消息队列接收来自sender1和sender2两个线程的消息，将消息显示在终端屏幕上，当收到内容为“end1”的消息时，就向sender1发送一个应答消息“over1”；当收到内容为“end2”的消息时，就向sender2发送一个应答消息“over2”；消息接收完成后删除消息队列，结束线程的运行。选择合适的信号量机制实现三个线程之间的同步与互斥。
二.实验思路
首先明确线程的功能，实验要求要有两个sender线程发送和一个receive线程进行接收
Receive：接收sender线程发送的信息并显示在终端，当接收到sender线程发送的end后，回应一个over并释放over信号。
Sender：发送消息，在用户输入exit后，sender发送end，接收receive线程的over信号。
信号量：
//互斥信号量mutex，互斥使用消息队列
sem_init(&mutex, 0, 1);
//同步信号量full,empty
sem_init(&full, 0, 0);
sem_init(&empty, 0, 5);
//用over信号判断某个sender线程的结束
sem_init(&over, 0, 0);
//display信号量实际作用只是为了能让sender线程和receive线程实现一发一收的格式
//不使用这两个信号量可能会无法保证线程的执行顺序
sem_init(&s_display, 0, 1);
sem_init(&r_display, 0, 0);
图1.线程关系
三.代码及实验结果
/*
2022/11/11
author:chenchen4396
*/
//API参考手册：https://www.bookstack.cn/read/linuxapi/SUMMARY.md
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <semaphore.h>
#include <fcntl.h>
pthread_t s1, s2, r;
sem_t mutex;
sem_t full, empty;
sem_t over;
sem_t s_display, r_display;
struct msgbuff
{
long msg_type; //消息类型，可以自定义，在使用msgrcv函数的时候会使用
char msg[100]; //消息数组大小
};
void receive(void *arg)
{
struct msgbuff buf;
int flag1 = 1;
int flag2 = 1;
int ret = -1;
while ((flag1 + flag2) != 0)
{
//初始化消息队列
memset(&buf, 0, sizeof(buf));
//互斥信号量mutex，资源信号量full
// mutex和full的wait顺序不能调换，否则会发生死锁，参考生存者与消费者模型
sem_wait(&r_display);
sem_wait(&full);
sem_wait(&mutex);
// msgrcv接受消息
// arg是传入的msgid
// 1代表msgtyp，指定一个接受的消息类型
// IPC_NOWAIT 如果需要等待，则不发送消息并且调用进程立即返回,避免阻塞
ret = msgrcv(*(int *)arg, &buf, sizeof(buf.msg), 1, IPC_NOWAIT);
if (strlen(buf.msg) != 0)
{
printf("receive: %s \n", buf.msg); //打印接收到的内容
printf("-----------------------------------------\n");
}
//判断sender1和sender2是否发送end
if (flag1 && strncmp(buf.msg, "end1", 4) == 0)
{
memset(&buf, 0, sizeof(buf));
strcpy(buf.msg, "over1");
//使over消息的msgtyp为2,方便分开接受
buf.msg_type = 2;
ret = msgsnd(*(int *)arg, &buf, sizeof(buf.msg), 0);
if (ret == -1)
{
printf("sender1 msgsnd error\n");
sem_post(&mutex);
exit(1);
}
sem_post(&over);
flag1 = 0;
}
else if (flag2 && strncmp(buf.msg, "end2", 4) == 0)
{
memset(&buf, 0, sizeof(buf));
strcpy(buf.msg, "over2");
buf.msg_type = 2;
ret = msgsnd(*(int *)arg, &buf, sizeof(buf.msg), 0);
if (ret == -1)
{
printf("sender2 msgsnd error\n");
sem_post(&mutex);
exit(1);
}
sem_post(&over);
flag2 = 0;
}
sem_post(&mutex);
sem_post(&empty);
sem_post(&s_display);
sleep(1);
}
printf("sender1 and sender2 all over!\n");
}
void sender1(void *arg)
{
struct msgbuff buf;
int flag = 1;
int ret = -1;
while (flag)
{
memset(&buf, 0, sizeof(buf));
sem_wait(&s_display);
sem_wait(&empty);
sem_wait(&mutex);
printf("sender1> ");
scanf("%s", buf.msg);
buf.msg_type = 1;
if (!strncmp(buf.msg, "exit", 4))
{
strcpy(buf.msg, "end1");
flag = 0;
}
else
{
strcat(buf.msg, " ——s1");
}
ret = msgsnd(*(int *)arg, &buf, sizeof(buf.msg), IPC_NOWAIT);
if (ret == -1)
{
printf("sender1 msgsnd error\n");
sem_post(&mutex);
exit(1);
}
sem_post(&r_display);
sem_post(&full);
sem_post(&mutex);
sleep(1);
}
sem_wait(&over);
sem_wait(&empty);
sem_wait(&mutex);
ret = msgrcv(*(int *)arg, &buf, sizeof(buf.msg), 2, IPC_NOWAIT);
if (strncmp(buf.msg, "over1", 5) == 0)
{
sem_post(&full);
sem_post(&mutex);
pthread_exit(NULL);
}
}
void sender2(void *arg)
{
struct msgbuff buf;
int flag = 1;
int ret = -1;
while (flag)
{
//初始化buf
memset(&buf, 0, sizeof(buf));
//等待信号量，申请顺序有些不能反!参考生产者消费者死锁问题
sem_wait(&s_display);
sem_wait(&empty);
sem_wait(&mutex);
printf("sender2> ");
scanf("%s", buf.msg);
//设置msg_type为1，与msgrcv第四个参数有关
buf.msg_type = 1;
if (!strncmp(buf.msg, "exit", 4)){
//当sender1输入exit，则对receive发送end1
strcpy(buf.msg, "end2");
flag = 0;
}
else{
strcat(buf.msg, " ——s2");
}
// msgsnd添加消息到队列
ret = msgsnd(*(int *)arg, &buf, sizeof(buf.msg), IPC_NOWAIT);
if (ret == -1){
printf("sender2 msgsnd error\n");
sem_post(&mutex);
exit(1);
}
//释放信号量
sem_post(&r_display);
sem_post(&full);
sem_post(&mutex);
sleep(1);
}
//接受over信号
sem_wait(&over);
sem_wait(&empty);
sem_wait(&mutex);
ret = msgrcv(*(int *)arg, &buf, sizeof(buf.msg), 2, IPC_NOWAIT);
if (strncmp(buf.msg, "over2", 5) == 0)
{
sem_post(&full);
sem_post(&mutex);
pthread_exit(NULL);
}
}
/*
初始化信号量
sem为初始化的信号量名,pshare为0表示只在该进程的所有线程间共享,非0则可以在进程之间共享，value为信号量的大小
kernel源码中有static inline void sema_init(struct semaphore *sem, int val)
sema_init是Linux内核的计数信号量实现初始化函数。
sem_init是Posix线程库的初始化程序（因此被用户空间代码使用）
*/
int main()
{
//互斥信号量mutex，互斥使用消息队列
sem_init(&mutex, 0, 1);
//同步信号量full,empty
sem_init(&full, 0, 0);
sem_init(&empty, 0, 5);
//用over信号判断某个sender线程的结束
sem_init(&over, 0, 0);
//display信号量实际作用只是为了能让sender线程和receive线程实现一发一收的格式
//不使用这两个信号量可能会无法保证线程的执行顺序
sem_init(&s_display, 0, 1);
sem_init(&r_display, 0, 0);
// 可以用判断一下信号量是否初始化成功，sem_getvalue(&mutex,&x);
int ret = 1; //返回值
key_t key = 100;//消息队列的key值
//IPC_CREAT表示key值不存在就创建，0666是设置权限
int msgid = msgget(key, IPC_CREAT | 0666);
if (msgid == -1)
{
printf("msgget error\n");
exit(1);
}
// pthread_create创建三个线程
//第二个参数用来 设置线程的属性，设为NULL
//第四个参数为传入执行函数的实参
ret = pthread_create(&s1, NULL, sender1, (void *)&msgid);
if (ret != 0)
{
printf("create sender1 error!\n");
exit(1);
}
ret = pthread_create(&r, NULL, receive, (void *)&msgid);
if (ret != 0)
{
printf("create receiver error!\n");
exit(1);
}
ret = pthread_create(&s2, NULL, sender2, (void *)&msgid);
if (ret != 0)
{
printf("create sender2 error!\n");
exit(1);
}
// pthread_join使三个进程阻塞
//为了回收资源，主线程会等待子线程结束。该函数就是用来等待线程终止的
pthread_join(s1, NULL);
pthread_join(s2, NULL);
pthread_join(r, NULL);
//删除消息队列
msgctl(msgid, IPC_RMID, 0);
return 0;
}图2.实验结果
四.遇到问题及解决方法
1.信号量的申请顺序不对，导致程序发生死锁，full信号和互斥型号量mutex申请顺序不对，造成了死锁，类似生产者消费者的经典死锁问题。
2.在未使用s_display和r_display信号量对线程执行顺序进行约束的时候，线程的执行顺序得不到保证，增加这两个信号量后，可以有效保证在sender线程后会执行receive线程。
3.信号量的使用和初始化要很注意，该实验的很多bug是来源于信号量的使用不恰当。
4.msgrcv 此类函数中的参数IPC_NOWAIT要注意，如果不设置此参数，会导致进程被挂起直到有消息进入队列。
ps：Sleep（）是多线程任务常用的一个函数，通过sleep()可以让线程直接告诉操作系统结束时间片进入休眠，在部分情况下可能可以提升很大的CPU利用率。两个display同步信号量可以让sender线程执行完成后就是receive线程，达成一发一收的效果。
五.参考文献
1 linux 多线程之信号量[EB/OL]. [].
【Linux】多线程 之 信号量_am brother的博客-CSDN博客.
2 . linux 多线程信号量[EB/OL]. [].
linux 多线程之信号量 sem_init_岁月斑驳7的博客-CSDN博客.
3 . linux API速查手册[EB/OL]. [].
https://www.bookstack.cn/read/linuxapi/SUMMARY.md.
4. . Linux源码[EB/OL]. [].
https://elixir.bootlin.com/linux/v4.16.3/source.
var code = "771885a0-7704-4c6b-bb9b-490157eeb898"
