HDU操作系统课程设计实验三
这是一个比较简单、容易的实验，前提条件是对Linux的信号量、进程创建与删除、管道通信、消息队列、共享内存等进程通信方式有一定的了解。注意：实验时要用到很多信号量，每个信号量创建之前需要unlink，但只有最后执行的unlink生效，所以注意运行多个程序的时候，带unlink的程序需要提前运行，不然会导致其他程序创建的信号量失效。
一、设计目的
(1)通过对Linux进程控制的相关系统调用的编程应用，进一步加深对进程概念的理解,明确进程和程序的联系和区别，理解进程并发执行的具体含义。
(2)通过Linux管道通信机制、消息队列通信机制、共享内存通信机制的应用，加深对不同类型的进程通信方式的理解。
(3)通过对Linux的Posix信号量及IPC信号量的应用，加深对信号量同步机制的理解。
(4)请根据自身情况，进一步阅读分析相关系统调用的内核源码实现。
二、内容要求
1.实现一个模拟的shell，基本功能加find、grep命令
2.实现一个管道通信程序，基本功能加有名管道通信
3.利用Linux的消息队列通信机制实现两个线程间的通信，基本功能加多进程（线程）同步、互斥通信
4.利用Linux的共享内存通信机制实现两个进程间的通信，基本功能加双向通信
三、实验内容
信号量的使用
POSIX无名信号量：
sem_t sem; //创建信号量
int sem_init(sem_t *sem, int pshared, unsigned int val); //pshared为0则线程间共享，pshared为1则父子进程共享
int sem_wait(sem_t *sem); //阻塞，信号量减一
int sem_trywait(sem_t *sem); //非阻塞，信号量减一
int sem_post(sem_t *sem); //信号量加一
int sem_destroy(sem_t *sem); //删除信号量
进程间共享则sem必须放在共享内存区域（mmap, shm_open, shmget），父进程的全局变量、堆、栈中存储是不行的
POSIX有名信号量：
sem_t *sem_open(const char *name, int oflag, mode_t mode, int val); //创建/打开信号量
//name：信号量的名字
//oflag：使用O_CREAT（如果信号量已经存在，则O_CREAT什么都不做函数也不出错）。如果使用O_CREAT|O_EXCL（表示如果信号量已存在，则创建失败，sem_open函数出错返回）
//mode：表示谁可以访问信号量
//value：指定信号量的初始值。取值范围是0~SEM_VALUE_MAX
int sem_wait(sem_t *sem); //阻塞，信号量减一
int sem_trywait(sem_t *sem); //非阻塞，信号量减一
int sem_post(sem_t *sem); //信号量加一
int sem_close(sem_t *sem); //关闭信号量
int sem_unlink(const char *name); //删除信号量
每个open的位置都要close和unlink，但只有最后执行的unlink生效
本文全部使用有名信号量。
1.实现一个模拟的shell，基本功能加find、grep命令
实验要求： 编写三个不同的程序cmd1.c、cmd2.c及cmd3.c，每个程序的功能自定，分别编译成可执行文件cmdl、cmd2及cmd3。然后再编写一个程序，模拟shell程序的功能：能根据用输入的字符串(表示相应的命令名)，为相应的命令创建子进程并让它去执行相应的程序，而父进程则等待子进程结束，然后再等待接收下一条命令。如果接收到的命令为exit，则父进程结束，退出模拟shell如果接收到的命令是无效命令，则显示“Command not found”，继续等待输入下一条命令。此外，还要实现find、grep命令，可以通过system()函数调用find、grep功能实现。
实验思路： 直接使用现有的C语言函数来实现shell命令即可。C程序调用shell脚本共有三种办法 ：system()、popen()、exec函数族。
system() ：不用你自己去产生进程，它已经封装了，直接加入自己的命令。定义格式：int system(const char * string); //string为shell命令
exec函数族：使用vfork()新建子进程，然后调用exec函数族。定义格式：
int exec函数(const char *path, const char *arg, ...); path为调用shell命令程序的地址，arg为具体参数，不一样的参数类型使用不一样的exec函数。
popen() ：定义格式：FILE * popen( const char * command,const char * type);通过创建一个管道，调用fork()产生一个子进程，执行一个shell以运行command命令来开启一个进程。参数type中“r”代表读取，“w”代表写入。
本文为了便于实现采用system()的方法，有同学采用exec函数族实现同样效果，但比较麻烦。
参考代码：
int main()
{
char command[100],cmd[55],token[50];
int status;
pid_t pid;
while(1)
{
printf("shell:");
scanf("%[^\n]%*c",command); //读入一行（同时去掉回车）
status = -1;
clear_space(command,token); //去除多余的空格
if(!strcmp(token,"cmd1") || !strcmp(token,"cmd2") || !strcmp(token,"cmd3")) //注：此处调用子程序命令与linux命令不同，直接使用程序名调用，用空的同学可以改成和linux命令一样，使用相对或者绝对路径调用。
{
pid = fork();
if(pid < 0)
{
printf("fork error\n");
}
else if(pid > 0)
{
wait(&status); //等待子进程运行结束
}
else
{
sprintf(cmd,"./%s",token); //添加相对路径
system(cmd); //system()调用命令
exit(0);
}
}
else if(!strcmp(token,"exit"))
{
printf("shell exit\n");
break ;
}
else if(!strcmp(token,"find") || !strcmp(token,"grep"))
{
system(command); //system()调用指令
}
else
{
printf("Command not found\n");
}
}
2.实现一个管道通信程序，基本功能加有名管道通信
实验要求： 由父进程创建一个管道，然后再创建三个子进程，并由这三个子进程利用管道与父进程之间进行通信：子进程发送信息，父进程等三个子进程全部发完消息后再接收信息。通信的具体内容可根据自己的需要随意设计，要求能试验阻塞型读写过程中的各种情况，测试管道的默认大小，并且要求利用Posix信号量机制实现进程间对管道的互斥访问。运行程序，观察各种情况下，进程实际读写的字节数以及进程阻塞唤醒的情况。此外，还要实现有名管道的功能。
实验思路：
**无名管道：**需要指定两个文件描述符，通过pipe()函数创建一个管道文件使其一端读文件一端写。对管道文件的读写和普通文件一样，直接用read()和write()函数。读写之前要调用close()关闭不需要的写读描述符。
int fd[2];
pipe(fd);
其中默认 fd[0]读文件，fd[1]写文件。
参考代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <semaphore.h>
#include <signal.h>
#include <fcntl.h>
int main()
{
int fd[2],pipe_num;
char buf[150];
sem_t *Mutex;
sem_t *send;
sem_t *receive;
pid_t pid;
memset(buf,0,sizeof(buf));
sem_unlink("Mutex");
sem_unlink("send");
sem_unlink("receive");
Mutex = sem_open("Mutex",O_CREAT,0666,1);
send = sem_open("send",O_CREAT,0666,1);
receive = sem_open("receive",O_CREAT,0666,0);
pipe_num = pipe(fd);
if(pipe_num == -1)
{
printf("pipe create error\n");
return 1;
}
pid = fork();
if(pid < 0)
{
sem_unlink(Mutex);
sem_unlink(send);
sem_unlink(receive);
printf("fork error\n");
return 2;
}
if(pid == 0)
{
close(fd[0]); //关闭读通道
sem_wait(send);
sem_wait(Mutex);
printf("pid:%d 进程1放入数据：",getpid());
scanf("%[^\n]%*c",buf);
write(fd[1],buf,strlen(buf)); //写数据
sleep(1);
sem_post(Mutex);
sem_post(receive);
}
else
{
close(fd[1]); //关闭写通道
sem_wait(receive);
sem_wait(Mutex);
read(fd[0],buf,150); //读数据
printf("pid:%d 父进程接收数据:%s\n",getpid(),buf);
sleep(1);
sem_post(Mutex);
sem_post(send);
}
}
有名管道： 有名管道使用的是fifo()函数，一个进程写数据，一个进程读数据，两个进程不能结束。对管道文件的读写和普通文件一样，直接用open()、write()和read()函数。
创建函数：
int mkfifo(const char * pathname, mode_t mode); //pathname为管道文件所在地址，mode为管道文件权限和open()函数一致。
参考代码：
//实现有名管道通信程序。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <semaphore.h>
#include <signal.h>
#include <fcntl.h>
#define fifofile "./fifomy"
int main()
{
int fd,pipe_num;
char buf[150];
sem_t *Mutex;
sem_t *send;
sem_t *receive;
pid_t pid;
memset(buf,0,sizeof(buf));
sem_unlink("Mutex");
sem_unlink("send");
sem_unlink("receive");
Mutex = sem_open("Mutex",O_CREAT,0666,1);
send = sem_open("send",O_CREAT,0666,1);
receive = sem_open("receive",O_CREAT,0666,0);
mkfifo(fifofile,0666); //创建有名管道
pid = fork();
if(pid < 0)
{
sem_unlink(Mutex);
sem_unlink(send);
sem_unlink(receive);
printf("fork error\n");
return 2;
}
if(pid == 0)
{
fd=open(fifofile,O_WRONLY); //以写方式打开管道文件
sem_wait(send);
sem_wait(Mutex);
printf("pid:%d 进程1放入数据：",getpid());
scanf("%[^\n]%*c",buf);
write(fd,buf,strlen(buf)); //写数据
close(fd); //关闭管道文件
sleep(1);
sem_post(Mutex);
sem_post(receive);
}
else
{
fd=open(fifofile,O_RDONLY); //以只读方式打开管道文件
sem_wait(receive);
sem_wait(Mutex);
read(fd,buf,150); //读数据
printf("pid:%d 父进程接收数据:%s\n",getpid(),buf);
close(fd); //关闭管道文件
unlink(fifofile); //删除有名管道文件
sleep(1);
sem_post(Mutex);
sem_post(send);
}
}
统计无名管道大小： 一个线程不断往无名管道中写入数据，直至管道写满后阻塞，另一个线程等待若干时间后（此时管道已写满），输出管道写入数据大小。
参考代码：
int i = 0; //全局变量，线程间可以共享
int *kwrite()
{
int pipefds[2];
pipe(pipefds);
char buf[1024];
memset(buf,100,sizeof(buf)); //填充写入字符串
for (i = 0; i < 1000; ++i)
{
write(pipefds[1], buf, sizeof(buf)); //写数据
}
close(pipefds[0]); //关闭管道
close(pipefds[1]); //关闭管道
}
int main()
{
pthread_t thread;
int lastnum = 0,t=0;
pthread_create(&thread,NULL,kwrite,&i); //开辟新线程，调用kwrite()函数
while(1)
{
if(i != lastnum)
{
lastnum = i;
t = 0;
}
else
{
t++;
if(t == 100000) //等待若干时间后，管道义阻塞
{
printf("管道大小为: %dk\n", i * 1);
break;
}
}
}
return 0;
}
3.利用Linux的消息队列通信机制实现两个线程间的通信，基本功能加多进程（线程）同步、互斥通信
实验要求： 编写程序创建三个线程：sender1线程、sender2线程和receiver线程，三个线程的功能描述如下：
①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”；消息接收完成后删除消息队列，结束线程的运行。选择合适的信号量机制实现三个线程之间的同步与互斥。
此外，还要实现多进程（线程）同步、互斥通信的功能。
实验思路：
消息队列函数：
1.msgget
功能：创建和访问一个消息队列
原型：int msgget(key_t key, int msgflag);
参数：
key：某个消息队列的名字，通过ftok()函数、IPC_PRIVATE对象创建或者自己指定一个数字编号，标识系统唯一的IPC资源
msgflag：有两个选项IPC_CREAT和IPC_EXCL，单独使用IPC_CREAT，如果消息队列不存在则创建之，如果存在则打开返回；单独使用IPC_EXCL是没有意义的；两个同时使用，如果消息队列不存在则创建之，如果存在则出错返回。
返回值：成功返回一个非负整数，即消息队列的标识码，失败返回-1
2.msgctl
功能：消息队列的控制函数
原型：int msgctl(int msqid, int cmd, struct msqid_ds *buf);
参数：
msqid：由msgget函数返回的消息队列标识码
cmd：有三个可选的值，IPC_STAT 把msqid_ds结构中的数据设置为消息队列的当前关联值；IPC_SET 在进程有足够权限的前提下，把消息队列的当前关联值设置为msqid_ds数据结构中给出的值；IPC_RMID 删除消息队列。
返回值：成功返回0，失败返回-1
3.msgsnd
功能：把一条消息添加到消息队列中
原型：int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
参数：
msgid：由msgget函数返回的消息队列标识码
msgp：指针指向准备发送的消息（对消息结构有要求）
msgze：msgp指向的消息的长度（不包括消息类型的long int长整型）
msgflg：默认为0
返回值：成功返回0，失败返回-1
消息结构必须小于系统规定的上限，同时以一个long int长整型开始，接受者以此来确定消息的类型。
struct msgbuf
{
long mtye;
char mtext[1];
};
4.msgrcv
功能：是从一个消息队列接受消息
原型：ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
参数：与msgsnd相同
返回值：成功返回实际放到接收缓冲区里去的字符个数，失败返回-1
参考代码：
sar.h
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>//信号量头文件
#define fifofile1 "/tmp/fifomy1"
#define fifofile2 "/tmp/fifomy2"
int fd1,fd2;//消息队列标识符
sem_t *sem_send;
sem_t *sem_receive;
sem_t *sem_over1;
sem_t *sem_over2;
sem_t *sem_receive1;
sem_t *sem_receive2;
//缓冲区mymsg
struct my_msgbuf
{
long mtype;//消息类型1为发送者的消息，2为接收的消息。
int sendid;//1为发送者1，2为发送者2。
char mtext[100];
};
void init_signal()
{
//初始化信号量
sem_send = sem_open("send", O_CREAT, 0666, 1);
sem_receive = sem_open("receive", O_CREAT, 0666, 0);
sem_over1 = sem_open("over1", O_CREAT, 0666, 0);
sem_over2 = sem_open("over2", O_CREAT, 0666, 0);
}
send.c
#include "sar.h"
int main()
{
char str[100];
int msgid;
struct my_msgbuf r_msg;//消息接受区
struct my_msgbuf s_msg;
init_signal();
fd1=open(fifofile1,O_RDONLY);
sem_wait(sem_over1);
read(fd1,&msgid,sizeof(int)); //通过有名管道读取消息队列的序号
s_msg.mtype = 1;
s_msg.sendid = 1;
printf("tid:%u 进程(线程)1: \n", (unsigned int)pthread_self());
while(1)
{
printf("发送：");
scanf("%[^\n]%*c",str);
sem_wait(sem_send);
if(strcmp(str, "exit") == 0)
{
strcpy(s_msg.mtext, "end1");
msgsnd(msgid, &s_msg, sizeof(struct my_msgbuf), 0); //发消息
sem_post(sem_receive);
break;
}
strcpy(s_msg.mtext, str);
msgsnd(msgid, &s_msg, sizeof(struct my_msgbuf), 0); //发消息
sem_post(sem_receive);
}
sem_wait(sem_over1);
msgrcv(msgid, &r_msg, sizeof(struct my_msgbuf), 0, 0); //收消息
printf("收到线程%u的消息: %s\n", r_msg.sendid, r_msg.mtext);
sem_post(sem_send);
return 0;
}
receiver.c
#include "sar.h"
int main()
{
int msgid;
int flag_over1 = 0;
int flag_over2 = 0;
struct my_msgbuf r_msg;//消息接受区
struct my_msgbuf s_msg;
msgid = msgget(IPC_PRIVATE, 0666|IPC_CREAT); //创建消息队列
sem_unlink("send");
sem_unlink("receive");
sem_unlink("over1");
sem_unlink("over2");
init_signal();
mkfifo(fifofile1,0666);
mkfifo(fifofile2,0666);
//通过有名管道发送消息队列序号
fd1=open(fifofile1,O_WRONLY);
fd2=open(fifofile2,O_WRONLY);
write(fd1,&msgid,sizeof(int));
sem_post(sem_over1);
write(fd2,&msgid,sizeof(int));
sem_post(sem_over2);
s_msg.mtype = 2;
s_msg.sendid = 3;
printf("tid:%u 进程(线程)3：\n", (unsigned int)pthread_self());
while (1)
{
sem_wait(sem_receive);
msgrcv(msgid, &r_msg, sizeof(struct my_msgbuf), 0, 0); //收消息
printf("收到线程%u的消息: %s\n", r_msg.sendid, r_msg.mtext);
if (r_msg.sendid == 1)
{
if (strcmp(r_msg.mtext, "end1") == 0)
{
printf("发送给线程1：over1\n");
strcpy(s_msg.mtext, "over1");
msgsnd(msgid, &s_msg, sizeof(struct my_msgbuf), 0); //发消息
sem_post(sem_over1);
flag_over1 = 1;
}
else
{
sem_post(sem_send);
}
}
else if(r_msg.sendid == 2)
{
if (strcmp(r_msg.mtext, "end2") == 0)
{
printf("发送给线程2：over2\n");
strcpy(s_msg.mtext, "over2");
msgsnd(msgid, &s_msg, sizeof(struct my_msgbuf), 0); //发消息
sem_post(sem_over2);
flag_over2 = 1;
}
else
{
sem_post(sem_send);
}
}
if (flag_over1 && flag_over2)
break;
}
sem_unlink("send");
sem_unlink("receive");
sem_unlink("over1");
sem_unlink("over2");
return 0;
}
4.利用Linux的共享内存通信机制实现两个进程间的通信，基本功能加双向通信
实验要求： 编写程序sender，它创建一个共享内存，然后等待用户通过终端输入一串字符，并将这串字符通过共享内存发送给receiver；最后,它等待receiver的应答，收到应答消息后，将接收到的应答信息显示在终端屏幕上，删除共享内存，结束程序的运行。编写receiver程序，它通过共享内存接收来自sender的消息，将消息显示在终端屏幕上，然后再通过该共享内存向sender发送一个应答消息“over”，结束程序的运行。选择合适的信号量机制实现两个进程对共享内存的互斥及同步使用。此外，还要实现双向通信的功能，可以使用双线程，一个线程专门收信息，一个进程专门发信息实现功能。
实验思路：
共享内存函数：
1.shmget()
功能：创建共享内存
原型：int shmget(key_t key, size_t size, int shmflg);
参数：
key：通过ftok()函数、IPC_PRIVATE对象创建或者自己指定一个数字编号，标识系统的唯一IPC资源。
size：是需要申请共享内存的大小。
shmflg：是共享内存创建方式：如果要创建新的共享内存，需要使用IPC_CREAT，IPC_EXCL，如果是已经存在的，可以使用IPC_CREAT或直接传0。
返回值：成功时返回一个新建或已经存在的的共享内存标识符，取决于shmflg的参数。失败返回-1并设置错误码。
2.shmat()
功能：挂接共享内存
原型：void *shmat(int shmid, const void *shmaddr, int shmflg);
参数：
shmid：为共享存储段的标识符。
shmaddr： shmaddr= 0，则存储段连接到由内核选择的第一个可以地址上（推荐使用）。
shmflg：若指定了SHM_RDONLY位，则以只读方式连接此段，否则以读写方式连接此段。
返回值：成功返回共享存储段的指针（虚拟地址），并且内核将使其与该共享存储段相关的shmid_ds结构中的shm_nattch计数器加1（类似于引用计数）；出错返回-1。
3.shmdt()
功能：去关联共享内存。当一个进程不需要共享内存的时候，就需要去关联。该函数并不删除所指定的共享内存区，而是将之前用shmat函数连接好的共享内存区脱离目前的进程。
原型：int shmdt(const void *shmaddr);
参数：
shmaddr：为连接以后返回的地址。
返回值：成功返回0，并将shmid_ds结构体中的 shm_nattch计数器减1；出错返回-1。
4.shmdt()
功能：断开共享内存连接。与shmat函数相反，是用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存。
原型：int shmdt(const void *shmaddr);
参数：
shmaddr：为连接的共享内存的起始地址。
返回值：成功返回0，出错返回-1。
4.shmctl()
功能：共享内存管理
原型：int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数：
shmid：为共享存储段标识符。
cmd：为指定的执行操作，设置为IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中。设置为IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内。设置为IPC_RMID：删除这片共享内存，buf为NULL。
buf：为共享内存管理结构体。
返回值：成功返回0，失败返回-1。
可以通过strcpy((char *)shmp, temp); 的方式与共享内存进行交互，shmp为共享内存的储存段指针，temp为传入的char数组首地址，反之则可以传出。为实现可以随机发送和接收，需要使用双线程读写或使用kbhit()等非阻塞函数读入（此函数Linux下没有需要从Windows下复制对应的函数源码），两种方法的效果一致。
参考代码：
sar.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>//信号量头文件
#include <glob.h>
#define MEM_MIN_SIZE 1024
#define KEY 1111
sem_t *sem_sender;
sem_t *sem_receiver1;
sem_t *sem_receiver2;
key_t key;
int shmid;
void *shmp;
void init_signal()
{
//初始化信号量
sem_sender = sem_open("sender", O_CREAT, 0666, 1);
sem_receiver1 = sem_open("receiver1", O_CREAT, 0666, 0);
sem_receiver2 = sem_open("receiver2", O_CREAT, 0666, 0);
shmid = shmget(KEY, MEM_MIN_SIZE, 0666|IPC_CREAT); //创建共享内存，key = 0(IPC_PRIVATE) 创建一个新对象。成功则返回id (一个与key相关的标识符)
if(shmid < 0)
{
printf("创建共享内存出错！\n");
exit(-1);
}
shmp = shmat(shmid, NULL, 0);//指定共享内存映射到新虚拟地址空间，返回起始地址
if((long long int)shmp == -1)
{
printf("映射内存出错！\n");
exit(-1);
}
}
send_receive.c
#include "msar.h"
pthread_t r_thread, s_thread;
void *send(void *arg)
{
char temp[MEM_MIN_SIZE], s_str[100];
while(1)
{
printf("发送：");
fflush(stdout); //立即将缓存输出到控制台显示
scanf("%[^\n]%*c",s_str);
sem_wait(sem_sender);
sprintf(temp,"%d:%s",*((pid_t *)arg),s_str);
strcpy((char *)shmp, temp); //写入内存
sem_post(sem_receiver2);
printf("OK\n");
if(!strcmp(s_str,"over"))
{
pthread_cancel(r_thread);
shmdt(shmp); //断开共享内存连接
break;
}
}
}
void *receive(void *arg)
{
char r_str[100], r_str_end[100], r_str_id[10], *p;
while(1)
{
sem_wait(sem_receiver1);
strcpy(r_str, (char *)shmp);
p = strchr(r_str,':');
*(p++) = '\0';
printf("\r接收到进程%s的消息：%s\n", r_str,p);
if(strcmp(p, "over") == 0)
{
pthread_cancel(s_thread); //双线程结束s_thread()函数
shmdt(shmp); //断开共享内存连接
shmctl(shmid, IPC_RMID, NULL); //删除共享内存
sem_unlink("sender");
sem_unlink("receiver1");
sem_unlink("receiver2");
break;
}
printf("发送：");
fflush(stdout); //立即将缓存输出到控制台显示
sem_post(sem_sender);
}
}
int main()
{
pid_t pid = getpid();
int res1 = 0,res2 = 0;
//初始化信号量
sem_unlink("sender");
sem_unlink("receiver1");
sem_unlink("receiver2");
init_signal();
printf("进程%d启动\n",pid);
res1 = pthread_create(&s_thread,NULL,send,&pid); //创建线程，调用s_thread()函数
res2 = pthread_create(&r_thread,NULL,receive,&pid); //创建线程，调用r_thread()函数
if(res1 || res2)
{
printf("create pthread failed\n");
return 1;
}
pthread_join(s_thread, NULL); //等待s_thread()函数线程结束
pthread_join(r_thread, NULL); //等待r_thread()函数线程结束
printf("进程%d结束\n",pid);
}
四、实验核心代码
shell文件夹
shell.c：实现一个模拟的shell，基本功能加find、grep命令。
cmd1.c：shell测试程序，输出cmd1。
cmd2.c：shell测试程序，输出cmd2。
cmd3.c：shell测试程序，输出cmd3。
Makefile：shell.c、cmd1.c、cmd2.c、cmd3.c的Makefile文件。
pipe文件夹
pipe.c：无名管道通信程序。
fifo.c：实现有名管道通信程序。
newfifo.c：统计无名管道的容量程序。
Makefile：pipe.c、fifo.c、newfifo.c的Makefile文件。
msgsar文件夹：
sar.h：进程间的消息队列通信头文件。
sender1.c：进程间的消息队列通信发送方1。
sender2.c：进程间的消息队列通信发送方2。
receiver.c：进程间的消息队列通信接收方。
Makefile：sender1.c、sender2.c、sender2.c的Makefile文件。
sharemy文件夹
msar.h：进程间的共享内存通信头文件。
msender.c：进程间的共享内存通信发送方。
mreceiver.c：进程间的共享内存通信接收方。
Makefile：msender.c、mreceiver.c的Makefile文件。