操作系统实验.docx
《操作系统实验.docx》由会员分享，可在线阅读，更多相关《操作系统实验.docx（36页珍藏版）》请在冰豆网上搜索。
操作系统实验
操作系统实验报告
姓名：
班级：
学号：
日期：
一、实验内容
（1）进程的创建。
（2）进程的控制。
（3）进程的软中断通信。
（4）进程的管道通信。
（5）消息的创建，发送和接收。
（6）共享存储区的创建、附接和段接。
二、实验目的
（1）加深对进程概念的理解，明确进程和程序的区别。
（2）进一步认识并发执行的实质。
（3）分析进程竞争资源现象，学习解决进程互斥的方法。
（4）了解Linux系统中进程通信的基本原理。
Linux系统的进程通信机构（IPC）允许在任意进程间大批量地交换数据。
本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。
三、实验题目
本实验有七个题：
第一题：
进程的创建。
编写一段源程序，使系统调用fork（）创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符：
父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。
试观察纪录屏幕上的显示结果，并分析原因。
[设计思路、数据结构、流程图]：
（1）调用一次fork（）方法，该方法会返回两次。
一次是在调用进程（也就是派生出的子进程的父进程）中返回一次，返回值是新派生的进程的进程ID。
一次是在子进程中返回，返回值是0，代表当前进程为子进程。
如果返回值为-1的话，则代表在派生新进程的过程中出错。
那么在程序中，我们就可以根据此返回值来判断当前进程是父进程还是子进程，来实现一些具体的操作。
（2）fork（）一次，有一次fork（）返回值不为零，一次返回值为零。
如果fork（）返回值不为零，则说明此时是父进程运行，输出’a’;如果fork（）返回值为零，则说明此时运行子进程，在此子进程中fork（）一次，有一次fork（）返回值不为零，一次返回值为零。
如果fork（）返回值不为零，则说明此时是子进程中的父进程运行，输出’b’;如果fork（）返回值为零，则说明此时运行子进程中的子进程中的子进程，输出’c’。
（3）由以上分析说明，系统将会产生三个进程，一个父进程，一个子进程，一个孙子进程，这三个进程是并行执行的，因此输出a、b、c的顺序是不一定的。
（4）本程序的流程图如下，但并不是一个流程就完了，而是三个进程分别执行三种不同的流程。
第二题：
进程的控制。
修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。
如果在程序中使用调用lockf（）来给每一个子进程加锁，可以实现进程之间的互斥，观察并分析出现的现象。
[设计思路、数据结构、流程图]：
（1）既然是在第一题的基础上进行改写那么其基本的设计思路和结构就和第一题相似，就是把每个进程输出的部分改成一个for循环就可以了
（2）使用wait（0）是把调用它的进程挂起，直到有别的进程终止它再开始执行。
用来实现进程间的同步。
（3）使用exit（0）是以0退出
（4）流程图与第一题相似，只是输出部分变成了for循环。
此时执行时由于printf（）单个输出不会被打断，所以每个字符串内部的字符顺序输出时不变。
但由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化
（5）如果调用lockf（）来给程序加锁的话，就不会出现（4）中所说的一个进程的输出被打断的问题，当一个进程在执行的时候，另外的进程不可以执行，只有当加锁的程序执行完之后，其他的程序才可以执行。
第三题：
进程的软中断通信。
①编写一段程序，使其现实进程的软中断通信。
要求：
使用系统调用fork（）创建两个子进程，再用系统调用signal（）让父进程捕捉键盘上来的中断信号（即按ctrl+c键）；当捕捉到中断信号后，父进程用系统调用Kill（）向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：
ChildProcessllisKilledbyParent!
ChildProcessl2isKilledbyParent!
父进程等待两个子进程终止后，输出如下的信息后终止
ParentProcessisKilled!
②在上面的程序中增加语句signal（SIGNAL,SIG_IGN）和signal（SIGQUIT,SIG_IGN）,观察执行结果，并分析原因。
[设计思路、数据结构、流程图]：
①
（1）fork（）一次，有一次fork（）返回值不为零，一次返回值为零。
（2）当fork（）的返回值不为零时，fork（）一次，有一次fork（）返回值不为零。
一次返回值为零。
（1）当返回值不为零时，初始化信号变量为1，等待5s，如果5s内没有ctrl+c信号发出的话，系统当前进程接收SIGALAM信号将信号变量为0，如果有接收到ctrl+c信号则也将信号变量为0，通过这五秒内检测信号变量是否为零来判断系统是否接收到ctrl+c信号。
之后向p1发送中断信号16、向p2发送中断信号17，等待两个子进程结束后输出”parentprocessiskilled!
”
（2）当返回值为零时，初始化信号变量为1，此时忽略ctrl+c信号的出现，若没有接收到17信号，则一直锁定。
当接收到17信号时将信号变量变为0，输出”childprocess2iskilledbyparent!
”输出完后解锁
（3）当fork（）的返回值为零时，初始化信号变量为1，此时忽略ctrl+c信号的出现，若没有接收到16信号，则一直锁定。
当接收到16信号时将信号变量变为0，输出”childprocess1iskilledbyparent!
”输出完后解锁。
（4）画出流程图如下，执行时是在5s内如果按下ctrl+c则直接输出；如果没有按下则5s后自动执行输出。
输出对这两种情况都是先执行两个子进程的语句，然后再输出父进程的语句。
②
（1）fork（）一次，有一次fork（）返回值不为零，一次返回值为零。
（2）当返回值不为零时，fork（）一次，有一次fork（）返回值不为零，一次返回值为零。
（1）当返回值不为零时，当接收到^c信号时转到IntDelete函数，此函数向两个子进程分别发送中断信号，然后等待两个子进程结束后输出”parentprocessiskilled”
（2）当返回值为零时，此时忽略^c信号，如果接收到父进程发来的中断信号则输出”childprocess1iskilled!
byparent”
（3）当返回值为零时，此时忽略^c信号，如果接收到父进程发来的中断信号则输出”childprocess2iskilled!
byparent”
（4）其流程图如下，输出时只要没有ctrl+c信号则不会产生任何输出，如果接收到ctrl+c信号则输出两个子进程的语句，然后输出父进程的语句
第四题：
进程的管道通信。
编制一段程序，实现进程的管理通信。
使用系统调用pipe（）建立一条管道线；两个子进程P1和P2分别向管道中写一句话：
Child1issendingamessage!
Child2issendingamessage!
而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
[设计思路、数据结构、流程图]：
（1）首先初始化管道数组信息fd[2]，创建一个管道。
fork（）一次，一次返回值为零，一次不为零。
（2）当返回值为零时，对管道写入口fd[1]加锁，并向fd[1]写入”child1processissendingmessage!
”之后sleep（5），给管道写入口解锁，向父进程发出终止信号。
（3）当返回值不为零时，fork（）一次，一次返回值为零，一次返回值不为零。
（1）当返回值为零的时候，对管道写入口fd[1]加锁，并向fd[1]写入”child2processissendingmessage!
”之后sleep（5）给管道写入口解锁，向父进程发出终止信号。
（2）当返回值不为零的时候，等待子进程终止信号之后，从管道读出口读取当时管道中的信息，然后输出信息，之后等待另一个子进程的终止信号之后，从管道读出口读出当时管道中的信息，然后输出信息
（4）当子进程写入数据且加上锁的时候执行sleep（5）的作用是，此时让另一子进程不可写入，且父进程执行到wait（0），使此子进程发出终止信号时，父进程一定会接收到，让另一子进程在这期间没有写入的机会。
（5）Pipe（fd）管道就是子进程进行写入数据，然后父进程读取，实现父子进程间的通信。
第五题：
消息的创建，发送和接收。
1使用系统调用msgget（）,msgsnd（）,msgrev（）,及msgctl（）编制一长度为1k的消息的发送和接收程序。
2观察上面的程序，说明控制消息队列系统调用msgctl（）在此起什么作用？
[设计思路、数据结构、流程图]：
（1）为了便于操作和观察结果，用一个程序为“引子”，先后fork（）两个子进程，SERVER和CLIENT，进行通信。
（2）SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。
当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER。
SERVER每接收到一个消息后显示一句“（server）received”。
（3）CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。
最后的一个消息，既是SERVER端需要的结束信号。
CLIENT每发送一条消息后显示一句“（client）sent”。
父进程在SERVER和CLIENT均退出后结束。
（4）msgget（key,flag）获得一个消息的描述符,该描述符制定一个消息队列以便于其他系统使用
第六题：
共享存储区的创建、附接和段接。
使用系统调用shmget（）,shmat（）,sgmdt（）,shmctl（）,编制一个与上述功能相同的程序。
[设计思路、数据结构、流程图]：
<程序设计>
（1）为了便于操作和观察结果，用一个程序为“引子”，先后fork（）两个子进程，SERVER和CLIENT，进行通信。
（2）SERVER端建立一个KEY为75的共享区,并将第一个字节置为-1.作为数据空的标志.等待其他进程发来的消息.当该字节的值发生变化时,表示收到了该消息,进行处理.然后再次把它的值设为-1.如果遇到的值为0,则视为结束信号,取消该队列,并退出SERVER.SERVER每接收到一次数据后显示”（server）received”.
（3）CLIENT端建立一个为75的共享区,当共享取得第一个字节为-1时,Server端空闲,可发送请求.CLIENT随即填入9到0.期间等待Server端再次空闲.进行完这些操作后,CLIENT退出.CLIENT每发送一次数据后显示”（client）sent”.
（4）父进程在SERVER和CLIENT均退出后结束.
第七题：
比较上述（5），（6）两种消息通信机制中数据传输的时间。
由于两种机制实现的机理和用处都不一样，难以直接进行时间上的比较。
如果比较其性能，应更加全面的分析。
（1）消息队列的建立比共享区的设立消耗的资源少.前者只是一个软件上设定的问题,后者需要对硬件操作,实现内存的映像,当然控制起来比前者复杂.如果每次都重新进行队列或共享的建立,共享区的设立没有什么优势。
（2）当消息队列和共享区建立好后,共享区的数据传输,受到了系统硬件的支持,不耗费多余的资源;而消息传递,由软件进行控制和实现,需要消耗一定的CPU资源.从这个意义上讲,共享区更适合频繁和大量的数据传输.
（3）消息的传递,自身就带有同步的控制.当等到消息的时候,进程进入睡眠状态,不再消耗CPU资源.而共享队列如果不借助其他机制进行同步,接受数据的一方必须进行不断的查询,白白浪费了大量的CPU资源.可见消息方式的使用更加灵活.
四、源程序（带注释）
（1）进程的创建。
#include
main（）
{
intp1,p2;
if（p1=fork（））/*父进程创建成功*/
printf（"a\n"）;
else
{
if（p2=fork（））/*子进程创建成功*/
printf（"b\n"）;
elseprintf（"c\n"）;/*子进程执行*/
}
printf（"\n"）;
}
（2）进程的控制。
/*程序一：
未加锁的程序*/
#include
main（）
{
intp1,p2,i;
if（p1=fork（））
{
for（i=0;i<10;i++）
printf（"parent%d\n",i）;
wait（0）;
exit（0）;
}
else
{
if（p2=fork（））
{
for（i=0;i<10;i++）
printf（"son%d\n",i）;
wait（0）;
exit（0）;
}
else
{
for（i=0;i<10;i++）
printf（"grandchild%d\n",i）;
exit（0）;
}
}
}
/*程序二：
加锁的程序*/
#include
main（）
{
intp1,p2,i;
if（p1=fork（））
{
lockf（1,1,0）;
for（i=0;i<10;i++）
printf（"parent%d\n",i）;
lockf（1,0,0）;
wait（0）;
exit（0）;
}
else
{
if（p2=fork（））
{
lockf（1,1,0）;
for（i=0;i<10;i++）
printf（"son%d\n",i）;
lockf（1,0,0）;
wait（0）;/*保证在子进程终止前，父进程不会终止*/
exit（0）;
}
else
{
lockf（1,1,0）;
for（i=0;i<10;i++）
printf（"daughter%d\n",i）;
lockf（1,0,0）;
exit（0）;
}
}
}
（3）进程的软中断通信。
/*程序一*/
#include
#include
#include
voidwaiting（）,stop（）,alarming（）;
intwait_mark;
main（）
{
intp1,p2;
if（p1=fork（））/*创建子进程p1*/
{
if（p2=fork（））/*创建子进程p2*/
{
wait_mark=1;
signal（SIGINT,stop）;/*接收到^c信号，转stop*/
signal（SIGALRM,alarming）;/*接受SIGALRM，转alarming*/
waiting（）;
kill（p1,16）;/*向p1发软中断信号16*/
kill（p2,17）;/*向p2发软中断信号17*/
wait（0）;/*同步*/
wait（0）;
printf（"parentprocessiskilled!
\n"）;
exit（0）;
}
else
{
wait_mark=1;
signal（17,stop）;
signal（SIGINT,SIG_IGN）;/*忽略^c信号*/
while（wait_mark!
=0）;/*等到中断信号17才会解锁输出*/
lockf（1,1,0）;
printf（"childprocess2iskilledbyparent!
\n"）;
lockf（1,0,0）;
exit（0）;
}
}
else
{
wait_mark=1;
signal（16,stop）;
signal（SIGINT,SIG_IGN）;/*忽略^c信号*/
while（wait_mark!
=0）/*等到中断信号17才会解锁输出*/
lockf（1,1,0）;
printf（"childprocess1iskilledbyparent!
\n"）;
lockf（1,0,0）;
exit（0）;
}
}
voidwaiting（）
{
sleep（5）;
if（wait_mark!
=0）
kill（getpid（）,SIGALRM）;
}
voidalarming（）
{
wait_mark=0;
}
voidstop（）
{
wait_mark=0;
}
/*程序二：
程序一增加语句*/
#include
#include
#include
intpid1,pid2;
intEndFlag=0;
intpf1=0;
intpf2=0;
voidIntDelete（）
{
kill（pid1,16）;
kill（pid2,17）;
}
voidInt1（）
{
printf（"childprocess1iskilled!
byparent\n"）;
exit（0）;
}
voidInt2（）
{
printf（"childprocess2iskilled!
byparent\n"）;
exit（0）;
}
main（）
{
intexitpid;
if（pid1=fork（））
{
if（pid2=fork（））
{
signal（SIGINT,IntDelete）;/*等到^c信号转IntDelete*/
waitpid（-1,&exitpid,0）;/*同步*/
waitpid（-1,&exitpid,0）;
printf（"parentprocessiskilled\n"）;
exit（0）;
}
else
{
signal（SIGINT,SIG_IGN）;
signal（17,Int2）;
pause（）;
}
}
else
{
signal（SIGINT,SIG_IGN）;
signal（16,Int1）;
pause（）;
}
}
（4）进程的管道通信。
#include
#include
#include
intpid1,pid2;
main（）
{
intfd[2];
charoutpipe[100],inpipe[100];
pipe（fd）;/*创建一个管道*/
while（（pid1=fork（））==-1）;
if（pid1==0）
{
lockf（fd[1],1,0）;
sprintf（outpipe,"child1processissendingmessage!
"）;
/*把串放入数组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,"child2processissendingmessage!
"）;
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）消息的创建，发送和接收。
#include
#include
#include
#include
#defineMSGKEY75/*定义关键词MEGKEY*/
structmsgform/*消息结构*/
{
longmtype;
charmtexe[100];/*文本长度*/
}msg;
intmsgqid,i;
voidCLIENT（）
{
inti;
msgqid=msgget（MSGKEY,0777|IPC_CREAT）;
for（i=10;i>=1;i--）
{
msg.mtype=i;
printf（"（client）sent\n"）;
msgsnd（msgqid,&msg,1030,0）;/*发送消息msg入msgid消息队列*/
}
exit（0）;
}
voidSERVER（）
{
msgqid=msgget（MSGKEY,0777|IPC_CREAT）;/*由关键字获得消息队列*/
do
{
msgrcv（msgqid,&msg,1030,0,0）;/*从队列msgid接受消息msg*/
printf（"（server）receive\n"）;
}while（msg.mtype!
=1）;/*消息类型为1时，释放队列*/
msgctl（msgqid,IPC_RMID,0）;
}
main（）
{
if（fork（））
{
SERVER（）;
wait（0）;
}
elseCLIENT（）;
}
（6）共享存储区的创建、附接和段接。
#include
#include
#include
#defineSHMKEY75/*定义共享区关键词*/
intshmid,i;
int*addr;
CLIENT（）
{
inti;
shmid=shmget（SHMKEY,1024,0777|IPC_CREAT）;/*获取共享区，长度1024，关键词SHMKEY*/
addr=shmat（shmid,0,0）;/*共享区起始地址为addr*/
f
升级会员 