HDU操作系统课程设计实验三

一、设计目的
二、内容要求
三、实验内容
- 信号量的使用
- 1.实现一个模拟的shell，基本功能加find、grep命令
- 2.实现一个管道通信程序，基本功能加有名管道通信
- 3.利用Linux的消息队列通信机制实现两个线程间的通信，基本功能加多进程（线程）同步、互斥通信
- 4.利用Linux的共享内存通信机制实现两个进程间的通信，基本功能加双向通信
四、实验核心代码

这是一个比较简单、容易的实验，前提条件是对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 1111sem_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文件。

完整实验代码详见：HDU-operation-system-course-design-code/实验三/