操作系统实验进程通信

实验报告

课程名称：操作系统

实验名称：进程通信

实验类型：

实验室名称：计算机应用实验室

实验报告撰写要求

一、实验前用预习报告纸撰写预习报告，预习报告包括以下内容

1．实验目的

2．实验用仪器设备、器材或软件环境

3．实验原理、方案设计、程序框图、预编程序等

4．实验过程中需要记录的实验数据表格

二、实验过程中，要认真观察，仔细记录

三、完成实验后用实验报告纸撰写实验报告，包括以下内容

1．仪器设备型号及编号

2．实验器材或软件环境

3．实验步骤、程序调试方法

4．实验数据处理及结果分析

5．实验中存在的问题

6．体会及思考题

四、报告撰写时，要求格式规范、书写整齐

预习报告□

报告成绩：指导教师审核（签名）：年月日

实验二进程通信

一、实验目的

1．加深对各种进程通信基本工作原理的理解。

2．理解和掌握Linux系统中进程通信API的应用方法。

3．进一步认识进程软中断通信、管道通信和消息队列通信的实质。

4．分析、设计进程软中断通信的实现方法。

5．分析、设计进程的管道通信，实现父子进程的单机通信机制。

6．分析、设计进程的消息队列通信，实现客户机/服务器通信机制。

二、实验类型

设计性实验。

三、实验预备知识

1．阅读Linux进程通信技术（软中断、管道和消息队列）的使用方法。

2．阅读Linux系统中单机和多机通信技术，掌握各种通信技术API的基本应用方法。

四、实验内容

1．进程的软中断通信

【举例1】

编制一段程序，使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按任意字母键和Enter键），当捕捉到中断信号后，父进程用系统调用kill()向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：child process 1 is killed by parent!

child process 2 is killed by parent!

父进程等待两个子进程终止后，输出以下信息后终止：

parent process is killed!

【程序】

#include

#include

#include

#include

void waiting(),stop();

int wait_mark;

main()

{

int p1,p2;

while((p1=fork())= =-1); /*创建进程p1*/

if(p1>0){

while((p2=fork())= =-1); /*创建进程p2*/

if(p2>0){

Printf(“parent run!\n”);

Printf(“p1=%d\n”,p1);

Printf(“p2=%d\n”,p2);

wait_mark=1;

getchar();

kill(p1,16); /*向p1发软中断信号16*/

kill(p2,17); /*向p2发软中断信号17*/

sleep(5); /*父进程睡眠5秒*/

wait(0); /*等待子进程结束，同步*/

wait(0); /*等待另一子进程结束，同步*/

lockf(stdout,1,0); /*标准输出加锁*/

printf(“parent process is killed!\n”);

lockf(stdout,0,0); /*标准输出解锁*/

exit(0); /*父进程终止*/

}else{

printf(“p2 run!\n”);

wait_mark=1;

signal(17,stop); /*接收父进程发来的软中断信号17，并转stop*/

waiting();

lockf(stdout,1,0); /*标准输出加锁*/

printf(“child process 2 is killed by parent!\n”);

lockf(stdout,0,0); /*标准输出解锁*/

exit(0); /*子进程p2终止*/

}

} else {

printf(“p1 run!\n”);

wait_mark=1;

signal(16,stop); /*接收父进程发来的软中断信号16，并转stop*/

waiting();

lockf(stdout,1,0); /*标准输出加锁*/

printf(“child process 1 is killed by parent!\n”);

lockf(stdout,0,0); /*标准输出解锁*/

exit(0); /*子进程p1终止*/

}

}

void waiting(){

printf(“waiting begin!\n”);

while(wait_mark!=0);

printf(“waiting end!\n”);

}

void stop(){

wait_mark=0;

printf(“signal stop!”);

}

【执行结果】

p1,p2和parent进程依次执行后，得到P1,P2的值为随机连续的值，按回车键输入中断信号后，通过signal()接收后，父进程向子进程发送信号，子进程p1,p2.parent进程依次结束，并打印相应的输出语句。

【分析原因】

先创建父进程，由父进程分别产生子进程p1和子进程p2，依次输出p1，p2，parent。随后用signal()接收给父进程中断信号，父进程通过kill()发信息给子进程，终止子进程，运行stop函数wait_mark=0;跳出waiting函数，输出parent process is killed!

【举例2】

在上面任务1中，增加语句signal(SIGINT,SIG_IGN)和语句signal(SIGQUIT,SIG_IGN)，

观察执行结果，并分析原因。这里signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN)分别为忽略“Ctrl+c”键信号以及忽略中断信号。

【程序】

#include

#include

#include

#include

int pid1,pid2;

int endflag=0,pf1=0,pf2=0;

void intdelete()

{ kill(pid1,16);

kill(pid2,17);

endflag=1;

}void int1(){

printf(“child process 1 is killed by parent!”);

exit(0);

}void int2(){

printf(“child process 2 is killed by parent!”);

exit(0);

}

main()

{

int exitpid;

signal(SIGINT,SIG_IGN);

signal(SIGQUIT,SIG_IGN);

while((pid1=fork())= =-1);

if(pid1= =0){

printf(“process 1 run!\n”);

signal(SIGUSR1,int1);

signal(16, SIG_IGN);

pause();

exit(0);

}else{

while((pid2=fork())= =-1);

if(pid2= =0){

printf(“process 2 run!\n”);

signal(SIGUSR2,int2);

signal(17, SIG_IGN);

pause();

exit(0);

}else{

printf(“parent run!\n”);

signal(SIGINT,intdelete);

waitpid(-1,&exitpid,0);

printf(“parent process is killed!\n”);

exit(0);

}

}

}

【执行结果】

Process 1 run! Process 2 run! Parent run! 按回车键后，进程也无法结束。

【分析原因】

由于忽略了终端与退出的信号，程序会一直保持阻塞状态而无法退出。

2．进程的管道通信

【举例】

编制一段程序，实现进程的管道通信。使用系统调用pipe()建立一条管道线。两个子进程p1和p2分别向管道各写一句话：

child 1 is sending a message!

child 2 is sending a message!

而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。

【程序】

#include

#include

#include

int pid1,pid2;

main()

{

int fd[3];

char outpipe[100],inpipe[100];

pipe(fd);

while((pid1=fork())= =-1);

if(pid1= =0){

printf(“p1 run!\n”);

lockf(fd[1],1,0);

sprintf(outpipe,”child 1 process is sending a message!”);

write(fd[1],outpipe,50);

sleep(1);

lockf(fd[1],0,0);

exit(0);

}else{

while((pid2=fork())= =-1);

if(pid2= =0){

printf(“p2 run!\n”);

lockf(fd[1],1,0);

sprintf(outpipe,”child 2 process is sending a message!”);

write(fd[1],outpipe,50);

sleep(1);

lockf(fd[1],0,0);

exit(0);

}else{

printf(“parent run!\n”);

wait(0);

read(fd[0],inpipe,50);

printf(“%s\n”,inpipe);

wait(0);

read(fd[0],inpipe,50);

printf(“%s\n”,inpipe);

exit(0);

}

}

}

【执行结果】

进程p1，p2，parent依次执行，随后打印，child 1 process is sending a message! child 2 process is sending a message! 还出现进程p1执行,parent执行p2再执行的情况，随后打印的结果相同。

【分析原因】

在该管道通信中，有时是子进程p1，p2往管道中传送数据完后父进程再从管道中读取数据，有时是子进程p1往管道中传送数据后父进程从管道中读取数据，然后子进程p2再往管道中传送数据，父进程再从管道中读取数据。

3．进程的消息队列通信

实验要求：

（1）实现客户机与服务器之间的通信程序。

1）基本要求：实现1台客户机对1台服务器；提高要求：实现n台客户机对1台服务器；

2）要求服务器分别接收客户机数据。

3）要求每个客户机与服务器采用消息队列通信机制来发送和接收消息。

（2）测试程序，给出测试结果并进行分析。

（3）书写预习报告和实验报告。

实验提示：

进程间消息队列通信主要用到的四个系统调用如下：

int msgget(key_t key,int msgflg)

int msgctl(int msgqid,int cmd,struct msqid_ds *buf)

int msgsnd(int msgqid,struct msgbuf *msgp, size_t msgsz,int msgflg)

int msgrcv(int msgqid,struct msgbuf *msgp, size_t msgsz,long msgtyp,int msgflg)

包含的头文件如下：

#include

#include

#include

【举例】

编制一个客户机进程，定义消息的格式，使用msgget()系统调用创建消息队列，使用msgsnd()和msgrcv()系统调用实现与服务进程之间消息的发送和接收，通信结束后使用msgctl()系统调用删除相关的消息队列。

（1）客户机程序设计

#include

#include

#include

#define MSGKEY 75

struct msgform{

long mtype;

char mtext[256];

};

main()

{

struct msgform msg;

int msgqid,pid,*pint;

msgqid=msgget(MSGKEY,0777);

pid=getpid();

pint=(int *)msg.mtext;

*pint=pid;

msg.mtype=1;

msgsnd(msgqid,&msg,sizeof(int),0);

msgrcv(msgqid,&msg,256,pid,0);

printf(“client:receive from pid%d\n”,*pint);

}

（2）服务器程序设计

#include

#include

#include

#define MSGKEY 75

struct msgform{

long mtype;

char mtext[256];

}msg;

int msgqid;

main()

{

int i,pid,*pint;

extern cleanup();

for(i=0;i<20;i++)

signal(i,cleanup);

msqid=msgget(MSGKEY,0777|IPC_CREAT);

for(;;){

msgrcv(msgqid,&msg,256,1,0);

pint=(int *)msg.mtext;

*pint=pid;

printf(“s erver:receive from pid%d\n”,*pint);

msg.mtype=pid;

*pint=getpid();

msgsnd(msgqid,&msg,sizeof(int),0);

}

}

void cleanup(){

msgctl(msgqid,IPC_RMID,0);

exit();

}

【执行结果】

先启动服务器，运行后无显示，在运行客户端，运行后同样无显示，此时再打开服务器的窗口可看到服务器显示：server:receive from pid 1108544020。

【分析原因】

先启动服务器，后启动客户端，两者通过端口进行连接，客户端通过一些系统调用实现通过消息队列的通信方式向服务器端发送信号及终止信息，服务器端接收后并作出反应。

五、实验结果图

六、实验心得及体会

通过本次实验，使我对各种进程通信基本工作原理有了更深理解，比如软中断通信，消息队列通信和管道通信，理解和掌握Linux系统中进程通信一些系统调用方法，进一步认识了进程间软中断通信、管道通信和消息队列通信的实质，今后还要多加练习，以增进理解。