实验三 进程间通信
实验三进程间通信（2学时）一、实验目的(1)了解什么是信号。
(2)熟悉LINUX系统中进程之间软中断通信的基本原理。
(3)熟悉LINUX支持的管道通信方式。
二、实验内容（1）编写一段程序，使其现实进程的软中断通信。
即：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按 ctrl+c 键）；当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：Child Process11 is killed by Parent!Child Process12 is killed by Parent!父进程等待两个子进程终止后，输出如下的信息后终止Parent Process is killed!要求：运行以下参考程序并分析结果。
<参考程序>#include<stdio.h>#include<signal.h>#include<unistd.h>#include<stdlib.h>void waiting(),stop(),alarming();int wait_mark;main(){int p1,p2;if(p1=fork()) /*创建子进程p1*/{if(p2=fork()) /*创建子进程p2*/{ //父进程wait_mark=1;signal(SIGINT,stop); /*接收到^c信号，转stop*/signal(SIGALRM,alarming);/*接受SIGALRM*/waiting();kill(p1,16); /*向p1发软中断信号16*/kill(p2,17); /*向p2发软中断信号17*/wait(0); /*同步*/wait(0);printf("parent process is killed!\n");exit(0); //会暂时停止目前进程的执行，直到有信号来到或子进程结束。
}else{wait_mark=1;signal(17,stop);signal(SIGINT,SIG_IGN); /*忽略 ^c信号*/while (wait_mark!=0);lockf(1,1,0);printf("child process2 is killed by parent!\n");lockf(1,0,0);exit(0);}}else{wait_mark=1;signal(16,stop);signal(SIGINT,SIG_IGN); /*忽略^c信号*/while (wait_mark!=0);lockf(1,1,0);printf("child process1 is killed by parent!\n");lockf(1,0,0);exit(0);}}void waiting(){sleep(5);if (wait_mark!=0)kill(getpid(),SIGALRM);}void alarming()wait_mark=0;}void stop(){wait_mark=0;}（2）修改上面的程序增加语句signal(SIGINT,SIG_IGN)和语句signal(SIGQUIT,SIG_IGN)，再观察程序执行时屏幕上出现的现象，并分析其原因。
这里，signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN)分别为忽略键信号以及忽略中断信号。
<程序>#include<stdio.h>#include<signal.h>#include<unistd.h>int pid1,pid2;int EndFlag=0;int pf1=0;int pf2=0;void IntDelete(){kill(pid1,16);kill(pid2,17);}void Int1(){printf("child process 1 is killed !by parent\n");exit(0);}void Int2(){printf("child process 2 is killed !by parent\n");exit(0);}main(){int exitpid;if(pid1=fork()){if(pid2=fork()){signal(SIGINT,IntDelete);waitpid(-1,&exitpid,0);waitpid(-1,&exitpid,0);printf("parent process is killed\n");exit(0);}else{signal(SIGINT,SIG_IGN);signal(17,Int2);pause();}}else{signal(SIGINT,SIG_IGN);signal(16,Int1);pause();}}（3）(选做)编制一段程序，实现进程的管道通信。
使用pipe()建立一条管道线。
两个子进程p1和p2分别向管道各写一句话： Child 1 is sending message!Child 2 is sending message!而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
〈程序〉#include <unistd.h>#include <signal.h>#include <stdio.h>int pid1,pid2;main( ){int fd[2];char outpipe[100],inpipe[100];pipe(fd); /*创建一个管道*/while ((pid1=fork( ))==-1);if(pid1==0){lockf(fd[1],1,0);sprintf(outpipe,"child 1 process is sending message!");/*把串放入数组outpipe中*/write(fd[1],outpipe,50); /*向管道写长为50字节的串*/sleep(5); /*自我阻塞5秒*/lockf(fd[1],0,0);exit(0);}else{while((pid2=fork( ))==-1);if(pid2==0){lockf(fd[1],1,0); /*互斥*/sprintf(outpipe,"child 2 process is sending message!");write(fd[1],outpipe,50);sleep(5);lockf(fd[1],0,0);exit(0);}else{wait(0); /*同步*/read(fd[0],inpipe,50); /*从管道中读长为50字节的串*/printf("%s\n",inpipe);wait(0);read(fd[0],inpipe,50);printf("%s\n",inpipe);exit(0);}}}〈运行结果〉延迟5秒后显示:child1 process is sending message!再延迟5秒:child2 process is sending message!〈分析〉请读者自行完成。
三、实验指导(一)信号1、信号的基本概念每个信号都对应一个正整数常量（称为signal number，即信号编号，定义在系统头文件<signal.h>中），代表同一用户的诸进程之间传送事先约定的信息的类型，用于通知某进程发生了某异常事件。
每个进程在运行时，都要通过信号机制来检查是否有信号到达。
若有，便中断正在执行的程序，转向与该信号相对应的处理程序，以完成对该事件的处理；处理结束后再返回到原来的断点继续执行。
实质上，信号机制是对中断机制的一种模拟，故在早期的UNIX版本中又把它称为软中断。
信号与中断的相似点：（1）采用了相同的异步通信方式；（2）当检测出有信号或中断请求时，都暂停正在执行的程序而转去执行相应的处理程序；（3）都在处理完毕后返回到原来的断点；（4）对信号或中断都可进行屏蔽。
信号与中断的区别：（1）中断有优先级，而信号没有优先级，所有的信号都是平等的；（2）信号处理程序是在用户态下运行的，而中断处理程序是在核心态下运行；（3）中断响应是及时的，而信号响应通常都有较大的时间延迟。
信号机制具有以下三方面的功能：（1）发送信号。
发送信号的程序用系统调用kill( )实现；（2）预置对信号的处理方式。
接收信号的程序用signal( )来实现对处理方式的预置；（3）收受信号的进程按事先的规定完成对相应事件的处理。
2、信号的发送信号的发送，是指由发送进程把信号送到指定进程的信号域的某一位上。
如果目标进程正在一个可被中断的优先级上睡眠，核心便将它唤醒，发送进程就此结束。
一个进程可能在其信号域中有多个位被置位，代表有多种类型的信号到达，但对于一类信号，进程却只能记住其中的某一个。
进程用kill( )向一个进程或一组进程发送一个信号。
3、对信号的处理当一个进程要进入或退出一个低优先级睡眠状态时，或一个进程即将从核心态返回用户态时，核心都要检查该进程是否已收到软中断。
当进程处于核心态时，即使收到软中断也不予理睬；只有当它返回到用户态后，才处理软中断信号。
对软中断信号的处理分三种情况进行：（1）如果进程收到的软中断是一个已决定要忽略的信号（function=1），进程不做任何处理便立即返回；（2）进程收到软中断后便退出（function=0）；（3）执行用户设置的软中断处理程序。
(二)所涉及的中断调用1、kill( )功能描述：用于向任何进程组或进程发送信号。
系统调用格式int kill(pid,sig)参数定义int pid,sig;其中，pid是一个或一组进程的标识符，参数sig是要发送的软中断信号。
（1）pid>0时，核心将信号发送给进程pid。
（2）pid=0时，核心将信号发送给与发送进程同组的所有进程。
（3）pid=-1时，核心将信号发送给所有用户标识符真正等于发送进程的有效用户标识号的进程。
2、signal( )功能描述：预置对信号的处理方式，允许调用进程控制软中断信号。
系统调用格式signal(sig,function)头文件为#include <signal.h>参数定义int sig;void (*func) ( )其中sig用于指定信号的类型，sig为0则表示没有收到任何信号，余者如下表：值名字说明01 SIGHUP 挂起（hangup）02 SIGINT 中断，当用户从键盘按^c键或^break键时03 SIGQUIT 退出，当用户从键盘按quit键时04 SIGILL 非法指令05 SIGTRAP 跟踪陷阱（trace trap），启动进程，跟踪代码的执行06 SIGIOT IOT 指令07 SIGEMT EMT指令08 SIGFPE 浮点运算溢出09 SIGKILL 杀死、终止进程10 SIGBUS 总线错误11 SIGSEGV 段违例（segmentation violation），进程试图去访问其虚地址空间以外的位置12 SIGSYS 系统调用中参数错，如系统调用号非法13 SIGPIPE 向某个非读管道中写入数据14 SIGALRM 闹钟。
实验三 进程通信doc(DOC)
实验三进程通信(二)实验目的：1、理解进程通信原理和基本技术2、了解linux系统进程间通信机构（IPC）；3、理解linux关于共享内存的概念；4、掌握linux支持进程间共享内存的系统调用；5、巩固进程同步概念。
实验内容：（一）闹钟。
用c语言编程，实现进程间通过信号进行通信。
用fork（）创建两个进程，子进程在等待5秒后用系统调用kill（）向父进程发送SIGALRM 信号，父进程用系统调用signal（）捕捉SIGALRM信号。
参考程序如下：#include <signal.h>#include <stdio.h>#include <unistd.h>static int alarm_fired = 0; //闹钟未设置//模拟闹钟void ding(int sig){alarm_fired = 1; //设置闹钟}int main(){int pid;printf("alarm application starting\n");if((pid = fork( )) == 0){ //子进程5秒后发送信号SIGALRM给父进程sleep(5);kill(getppid(), SIGALRM);//exit(0);return 0;}//父进程安排好捕捉到SIGALRM信号后执行ding函数printf("waiting for alarm to go off\n");(void) signal(SIGALRM, ding);pause(); //挂起父进程，直到有一个信号出现if (alarm_fired)printf("Ding!\n");printf("done\n");//exit(0);return 0;}调试并运行程序。
观察程序运行结果。
（二）共享内存。
实现利用共享内存机制的生产者/消费者问题的解决方案。
操作系统实验三进程的管道通信
实验三进程的管道通信一、实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）学习进程创建的过程，进一步认识并发执行的实质；（3）分析进程争用资源的现象，学习解决进程互斥的方法；（4）学习解决进程同步的方法；（5）掌握Linux系统进程间通过管道通信的具体实现方法。
二、实验内容及要求：（1）使用系统调用pipe()建立一条管道线，两个子进程分别向管道写一句话（写的内容自己定，但要有该进程的一些信息）；（2）父进程从管道中读出来自两个子进程的消息，显示在屏幕上；（3）要求：父进程首先接收子进程p1发来的消息，然后再接收子进程p2发来的消息；（4）两个子进程要并发执行；（5）实现管道的互斥使用。
当一个子进程正在对管道进行写操作时，另一个欲写入管道的子进程必须等待。
使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定；（6）实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。
三、实现：相关的系统调用fork() 用于创一个子进程。
格式：int fork();返回值：在子进程中返回0；在父进程中返回所创建的子进程的ID值；当返回-1时，创建失败。
wait() 常用来控制父进程与子进程的同步。
在父进程中调用wait()，则父进程被阻塞，进入等待队列，等待子进程结束。
当子进程结束时，父进程从wait()返回继续执行原来的程序。
返回值：大于0时，为子进程的ID值；等于-1时，调用失败。
exit() 是进程结束时最常调用的。
格式：void exit( int status); 其中，status为进程结束状态。
pipe() 用于创建一个管道格式：pipe(int fd);其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组，fd[0]是管道的读端口，用于从管道读出数据,fd[1]是管道的写端口，用于向管道写入数据。
实验三-进程通讯实验报告
实验三进程通讯实验报告【姓名】【学号】【实验题目】进程通讯——消息队列与共享存储区【实验目的】（1）掌握进程间通讯的编程方法；（2）加深对进程并发执行的理解；（3）学习利用消息队列和共享存储区实现进程通信的方法。
【实验内容】设计一个多进程并发运行的程序，它由不同的进程完成下列工作：（1）接收键盘输入进程负责接收用户的键盘输入，并以适当的方式将由键盘获得的数据交给其它进程处理。
（2）显示进程负责全部数据显示任务，包括键盘输入数据的显示和提示信息的显示。
（3）分发数据进程将键盘输入的数据分为3类，即字母、数字和其它，并分别将字母写入文件letter.txt 中，数字写入文件number.txt中，除字母和数字外其它数据丢弃。
【实验要求】1、程序能以适当的方式提示用户输入数据；2、提示用户有数据被丢弃；3、全部的显示任务必须由显示进程完成；4、整个程序能够连续处理多组输入数据，直到用户输入“quit”字符串，整个程序结束；5、进一步要求：同时采用共享存储区和消息2种方法实现进程之间的通信，并比较这2种通信方法的利弊。
【实验方法】1、利用fork()函数创建2个子进程，用一个父进程和两个子进程完成上面的三个实验任务，用子进程1实现分发数据任务，子进程2实现接受键盘输入任务，父进程实现全部的显示任务。
2、同时通过共享存储区和消息队列两种进程通讯方式实现上面三个进程之间的同步和互斥。
3、利用while()循环、kill()函数和signal()函数实现连续多组数据输入。
【程序结构】·数据结构：消息队列、字符数组；·程序结构：顺序结构、if-else分支结构和while循环结构；·主要算法：无特别算法【实验结果】1、有代表性的执行结果：[stud13@localhost stud13]$ cc ipc.c[stud13@localhost stud13]$ ./a.outPlease input a line:∟operatingsystem01234-=,.Your message is:operatingsystem01234-=,.The characters deserted are:-=,.Please input a line:∟xushengju6651001!@#$%^&*()Your message is:xushengju6651001!@#$%^&*()The characters deserted are:!@#$%^&*()Please input a line:∟Hello123Your message is:Hello123Please input a line:∟quit[stud13@localhost stud13]$ cat letter.txtOperatingsystemxushengjuHello[stud13@localhost stud13]$ cat number.txt 012346651001123[stud13@localhost stud13]$2、结果分析及解释：在创建子进程1时，由于先返回子进程的ID号，msgrcv(msgid,&msg,BUFSIZE,0,0)一直都是非0值，故循环等待。
实验3 进程间通信
实验3 进程间通信1、实验目的Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。
本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制,理解进程处理信号的方法，使用用户自定义的信号处理程序。
分析进程竞争资源现象，学习解决进程互斥的方法。
了解linux系统中进程通信的基本原理。
2、实验预备内容阅读Linux系统的msg.c、sem.c和shm.c等源码文件，熟悉Linux的三种机制。
3、实验内容（1）编写一段程序，使其现实进程的软中断通信。
要求：使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill()向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：Child Processll is Killed by Parent!Child Processl2 is Killed by Parent!父进程等待两个子进程终止后，输出如下的信息后终止Parent Process is Killed!（2）进程的管道通信编制一段程序，实现进程的管理通信。
使用系统调用pipe()建立一条管道线；两个子进程P1和P2分别向管道中写一句话：Child 1 is sending a message!Child 2 is sending a message!而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
（3）消息通信使用系统调用msgget( ), msgsnd( ), msgrcv( )及msgctl()编制一长度为1K的消息发送和接收的程序。
〈程序设计〉a）为了便于操作和观察结果，用一个程序为“引子”，先后fork( )两个子进程，SERVER 和CLIENT，进行通信。
b）SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。
进程实验-进程间通信(管道、消息、共享内存、软中断)
进程实验3 Linux 进程间通信一、软中断信号的处理，实现同一用户的各进程之间的通信。
●相关的系统调用⏹kill(pid ,sig)：发送信号⏹signal（sig, func）：指定进程对信号sig的处理行为是调用函数func。
●程序清单#include <unistd.h>#include <stdio.h>#include <signal.h>void waiting();void stop();int wait_mark;main(){int p1,p2;while((p1=fork())==-1);if(p1>0){while((p2=fork())==-1);if(p2>0){ printf("parent\n");/*父进程在此完成某个操作、或接收到用户从键盘输入的特殊按键命令后发出下面的信号。
这里省略。
*/kill(p1,16);kill(p2,17);wait(0);wait(0);printf("parent process id killed! \n");exit(0);}else/* p2==0*/{printf("p2\n");wait_mark=1;signal(17,stop);waiting();printf("child process 2 is killed by parent! \n");exit(0);}}else/*p1==0*/{printf("p1\n");wait_mark=1;signal(16,stop);waiting();printf("child process 1 is kelled by parent! \n");exit(0);}}void waiting(){while(wait_mark!=0);}void stop(){wait_mark=0;}●输入并运行此程序，分析程序的运行结果。
实验三、进程通信(一) ——管道及共享内存
（1）阅读以上父子进程利用管道进行通信的例子（例1），写出程序的运行结果并分析
实验代码：
#include<stdio.h>
main()
{ int x,fd[2];
char buf[30],s[30];
pipe(fd);
while ((x=fork())==-1);
if (x==0)
}
write(fe[1],s,30);
wait(0);
}
运行结果：
（3）阅读例2的程序，运行一次该程序，然后用ipcs命令查看系统中共享存储区的情况，再次执行该程序，再用ipcs命令查看系统中共享内存的情况，对两次的结果进行比较，并分析原因。最后用ipcrm命令删除自己建立的共享存储区。（有关ipcs和ipcrm介绍见后面一页）
addr=shmat(shmid,0,0);/*挂接，并得到共享区首地址*/
printf ("addr 0x%x\n",addr);
pint=(char *)addr;
for (i='a';i<='e';i++) *pint++=i;
pause();/*等待接收进程读*/
}
cleanup()
{
shmctl(shmid,IPC_RMID,0);
（2）每个同学登陆两个窗口，先在一个窗口中运行例3程序1（或者只登陆一个窗口，先在该窗口中以后台方式运行程序1），然后在另一个窗口中运行例3程序2，观察程序的运行结果并分析。运行结束后可以用ctrl+c结束程序1的运行。
（3）编写程序：使用系统调用shmget()，shmat()，shmdt()，shmctl()，编制程序。要求在父进程中生成一个30字节长的私有共享内存段。接下来，设置一个指向共享内存段的字符指针，将一串大写字母写入到该指针指向的存贮区。调用fork()生成子进程，让子进程显示共享内存段中的内容。接着，将大写字母改成小写，子进程修改共享内存中的内容。之后，子进程将脱接共享内存段并退出。父进程在睡眠5秒后，在此显示共享内存段中的内容（此时已经是小写字母）。
操作系统实验三进程的管道通信精编版
操作系统实验三进程的管道通信精编版MQS system office room 【MQS16H-TTMS2A-MQSS8Q8-MQSH16898】实验三进程的管道通信一、实验目的：（1）加深对进程概念的理解，明确进程和程序的区别；（2）学习进程创建的过程，进一步认识并发执行的实质；（3）分析进程争用资源的现象，学习解决进程互斥的方法；（4）学习解决进程同步的方法；（5）掌握Linux系统进程间通过管道通信的具体实现方法。
二、实验内容及要求：（1）使用系统调用pipe()建立一条管道线，两个子进程分别向管道写一句话（写的内容自己定，但要有该进程的一些信息）；（2）父进程从管道中读出来自两个子进程的消息，显示在屏幕上；（3）要求：父进程首先接收子进程p1发来的消息，然后再接收子进程p2发来的消息；（4）两个子进程要并发执行；（5）实现管道的互斥使用。
当一个子进程正在对管道进行写操作时，另一个欲写入管道的子进程必须等待。
使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定；（6）实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。
三、实现：相关的系统调用fork()用于创一个子进程。
格式：intfork();返回值：在子进程中返回0；在父进程中返回所创建的子进程的ID 值；当返回-1时，创建失败。
wait()常用来控制父进程与子进程的同步。
在父进程中调用wait()，则父进程被阻塞，进入等待队列，等待子进程结束。
当子进程结束时，父进程从wait()返回继续执行原来的程序。
返回值：大于0时，为子进程的ID值；等于-1时，调用失败。
exit()是进程结束时最常调用的。
格式：voidexit(intstatus);其中，status为进程结束状态。
pipe()用于创建一个管道格式：pipe(intfd);其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组，fd[0]是管道的读端口，用于从管道读出数据,fd[1]是管道的写端口，用于向管道写入数据。
实验三_进程间通信 (1)
实验三线程控制和进程间通信一、实验目的通过Linux管道通信机制、消息队列通信机制的使用，加深对不同类型的进程通信方式的理解。
二、实验内容：1.熟悉Linux的管道通信机制2.熟悉Linux的消息队列通信机制三、思考1.有名管道和无名管道之间有什么不同？2.管道的读写与文件的读写有什么异同？3.Linux消息队列通信机制中与教材中的消息缓冲队列通信机制存在哪些异同？四、实验指导<一>Linux管道通信机制管道是所有UNIX都提供的一种进程间通信机制，它是进程之间的一个单向数据流，一个进程可向管道写入数据，另一个进程则可以从管道中读取数据，从而达到进程通信的目的。
1.无名管道无名管道通过pipe()系统调用创建，它具有如下特点：(1)它只能用于具有亲缘关系的进程（如父子进程或者兄弟进程）之间的通信。
(2)管道是半双工的，具有固定的读端和写端。
虽然pipe()系统调用返回了两个文件描述符，但每个进程在使用一个文件描述符之前仍需先将另一个文件描述符关闭。
如果需要双向的数据流，则必须通过两次pipe()建立起两个管道。
(3)管道可以看成是一种特殊的文件，对管道的读写与文件的读写一样使用普通的read、write等函数，但它不是普通的文件，也不属于任何文件系统，而只存在于内存中。
2.pipe系统调用（1）函数原型#include <unistd.h>int pipe(int filedes[2]);（2）参数filedes参数是一个输出参数，它返回两个文件描述符，其中filedes[0]指向管道的读端，filedes[1]指向管道的写端。
（3）功能pipe在内存缓冲区中创建一个管道，并将读写该管道的一对文件描述符保存在filedes所指的数组中，其中filedes[0]用于读管道，filedes[1]用于写管道。
（4）返回值成功返回0；失败返回-1，并在error中存入错误码。
（5）错误代码EMFILE：进程使用的文件描述符过多ENFILE ：系统文件表已满EFAULT ：非法参数filedes3.无名管道的阻塞型读写管道缓冲区有4096B的长度限制，因此，采用阻塞型读写方式时，当管道已经写满时，写进程必须等待，直到读进程取走信息为止。
进程通讯管理实验报告(3篇)
第1篇一、实验目的1. 理解进程通信的概念和原理；2. 掌握进程通信的常用机制和方法；3. 能够使用进程通信机制实现进程间的数据交换和同步；4. 增强对操作系统进程管理模块的理解。
二、实验环境1. 操作系统：Linux2. 编程语言：C3. 开发环境：GCC三、实验内容1. 进程间通信的管道机制2. 进程间通信的信号量机制3. 进程间通信的共享内存机制4. 进程间通信的消息队列机制四、实验步骤1. 管道机制（1）创建管道：使用pipe()函数创建管道，将管道文件描述符存储在两个变量中，分别用于读和写。
（2）创建进程：使用fork()函数创建子进程，实现父子进程间的通信。
（3）管道读写：在父进程中，使用read()函数读取子进程写入的数据；在子进程中，使用write()函数将数据写入管道。
（4）关闭管道：在管道读写结束后，关闭对应的管道文件描述符。
2. 信号量机制（1）创建信号量：使用sem_open()函数创建信号量，并初始化为1。
（2）获取信号量：使用sem_wait()函数获取信号量，实现进程同步。
（3）释放信号量：使用sem_post()函数释放信号量，实现进程同步。
（4）关闭信号量：使用sem_close()函数关闭信号量。
3. 共享内存机制（1）创建共享内存：使用mmap()函数创建共享内存区域，并初始化数据。
（2）映射共享内存：在父进程和子进程中，使用mmap()函数映射共享内存区域。
（3）读写共享内存：在父进程和子进程中，通过指针访问共享内存区域，实现数据交换。
（4）解除映射：在管道读写结束后，使用munmap()函数解除映射。
4. 消息队列机制（1）创建消息队列：使用msgget()函数创建消息队列，并初始化消息队列属性。
（2）发送消息：使用msgsnd()函数向消息队列发送消息。
（3）接收消息：使用msgrcv()函数从消息队列接收消息。
（4）删除消息队列：使用msgctl()函数删除消息队列。
实验三 进程间的通信
实验三进程间的通信1、实验目的学习如何利用管道机制、消息缓冲队列进行进程间的通信，并加深对上述通信机制的理解。
2、实验内容（1）了解系统调用pipe()、msgget()、msgsnd()、msgrcv()的功能和实现过程。
（2）编写一段程序，使其用管道来实现父子进程之间的进程通信。
子进程向父进程发送自己的进程标识符，以及字符串“is sending a message to parent!”。
父进程则通过管道读出子进程发来的消息，将消息显示在屏幕上，然后终止。
（3）编写一段程序，使用消息缓冲队列来实现client进程和server进程之间的通信。
server进程先建立一个关键字为SVKEY （如75）的消息队列，然后等待接收类型为REQ（如1）的消息；在收到请求消息后，它便显示字符串“serving for client”和接收到的client进程的进程标识数，表示正在为client进程服务；然后再向client进程发送一应答消息，该消息类型是client 进程的进程标识数，而正文则是server进程自己的标识数。
client进程则向消息队列发送类型为REQ的消息（消息的正文为自己的进程标识数）以取得server进程的服务，并等待server 进程发来的应答；然后显示字符串“receive reply form”和接收到的server进程的标识符。
1、client.c2、server.c3、思考题上述通信机制各有什么特点？它们分别适合于何种场合？答：管道通信的特点：（1）管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；（2）只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；（3）单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
（4）数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。