h〉
main（）
{
iｎtｐ1,p2,i；
if（p１=fork（））
｛
ﻩﻩfoｒ（ｉ＝０；i〈5０0；i++）
pｒｉntｆ（＂parｅnt%d＼n"，i）;
ｗaｉt（０）;／＊ 保证在子进程终止前,父进程不会终止＊／
ﻩﻩexｉt（0）;
}
eｌse
ﻩ{
ﻩiｆ（p2=fork（））
ﻩ{
ﻩｆor（i=0;ｉ<500;ｉ+＋）
ﻩﻩﻩprintf（”ｓon%ｄ\n＂，i）;
wait（0）;／*保证在子进程终止前，父进程不会终止＊/
ﻩﻩﻩｅxit（0）； /*向父进程信号0且该进程推出*/
}
ｅｌsｅ
ﻩﻩﻩ{
ﻩﻩfoｒ（ｉ=0;i〈50０;i＋+）
ﻩprintｆ（“grandcｈilｄ％d＼n”，ｉ）;
ﻩﻩeｘit（0）；
}
ﻩ｝
｝
<运行结果〉
ﻩｐarｅnt…。
ｓoｎ…
ｇｒandchild…
graｎｄｃhiｌｄ…
ﻩ或grａndｃｈilｄ
…soｎ
ﻩ…ｇranｄcｈild
…son
ﻩ…pａreｎt
ﻩ分析:
由于函数prｉnｔf（）输出的字符串之间不会被中断,因此,每个字符串内部的字符顺序输出时不变.但是,由于进程并发执行时的调度顺序和父子进程的抢占处理机问题，输出字符串的顺序和先后随着执行的不同而发生变化.这与打印单字符的结果相同.
〈程序２〉
＃incｌude
mａin（）
{
ｉntp1，ｐ2,i;
ﻩif（p1=ｆorｋ（））
{
ﻩlockf（１,1，0）;
foｒ（i=0；i〈50０;ｉ＋+）
ﻩpｒｉｎｔf（”pａrｅnt％d＼ｎ"，ｉ）;
ﻩloｃkf（1,0，0）；
ﻩwaiｔ（0）;/*保证在子进程终止前，父进程不会终止＊/
ﻩ eｘiｔ（0）；
｝
else
｛
ｉｆ（p２=forｋ（））
ﻩ｛
ﻩﻩlocｋf（１,1,０）;
ﻩfor（i=0；i〈5００；i++）
ｐrinｔf（”ｓon%ｄ\ｎ",i）；
ﻩloｃkf（１,0,0）；
waiｔ（0）;/*保证在子进程终止前，父进程不会终止*/
ﻩeｘit（0）;
ﻩﻩﻩ}
ﻩelse
ﻩ｛
ﻩloｃkf（1,1，0）;
ﻩｆoｒ（i=０;i<50０;i++）
printf（”ｄaughter %d\n＂，i）；
ｌoｃｋf（1,0，0）;
ﻩexit（0）；
}
ﻩ｝
}
＜运行结果〉
输出ｐarent块,sｏn块,grandcｈild块的顺序可能不同,但是每个块的输出过程不会被打断.
分析：
因为上述程序执行时，ｌｏckｆ（1,１,０）锁定标准输出设备,locｋf（１,0,0）解锁标准输出设备，在ｌｏｃｋf（1,1，0）与lｏcｋf（1,0，０）中间的fｏr循环输出不会被中断,加锁与不加锁效果不相同。
3．软中断通信
<任务1〉
编制一段程序，使用系统调用fｏｒk（）创建两个子进程，再用系统调用ｓignaｌ（）让父进程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后,父进程用系统调用kiｌl（）向两个子进程发出信号,子进程捕捉到信号后，分别输出下列信息后终止:
chiｌｄpｒｏcess1iｓkiｌlｅdｂypareｎt!
chｉldprｏｃess2is killｅdｂｙ pａｒent!
父进程等待两个子进程终止后,输出以下信息后终止：
pａrent procｅｓsiｓkillｅd!
〈程序流程图〉
〈程序〉
#inｃlｕｄe〈ｓtdio.h＞
＃ｉnｃluｄe<ｓｉgnal。
h〉
#iｎcludｅ〈uｎistd。
h〉
voidwaitiｎg（），stop（）,alarming（）;
iｎｔwａｉｔ_mark;
main（）
｛
ﻩｉntｐ1,p２；
iｆ（ｐ1＝foｒk（）） /*创建子进程ｐ1*/
ﻩ{
ﻩiｆ（p2=fｏrk（））ﻩ ﻩ／*创建子进程p2＊／
｛
ﻩﻩwａiｔ_mａrk=1；
ﻩﻩsiｇnal（SIGＩNT,sｔoｐ）; /*接收到^ｃ信号，转stop＊/
ﻩﻩsignal（SＩGAＬＲM,ａlarming）;/*接受SＩＧAＬRM
ﻩﻩwaiｔｉng（）;
ﻩｋill（ｐ1,1６）; /*向p１发软中断信号16*/
ﻩﻩﻩｋill（ｐ2，17）; /＊向p2发软中断信号１7＊/
ﻩ
wait（0）； /*同步*/
ﻩﻩｗait（0）;
ﻩﻩprintf（”pａｒｅntｐrocess iskｉｌｌeｄ！
\n＂）;
ﻩﻩｅxit（0）；
ﻩ｝
ﻩﻩelｓe
ﻩ ｛
ﻩﻩwaiｔ_maｒk=１;ﻩﻩ
ﻩsigｎaｌ（17，stop）;
siｇnal（SIＧINＴ，SIＧ_IＧＮ）;/*忽略＾ｃ信号*/
ｗhiｌe （ｗａit＿marｋ!
=０）;
ﻩloｃkf（1，1，0）；
ﻩprintｆ（”childprocess２ ｉｓkilledｂｙ parent!
\n"）;
ﻩﻩlockf（1,0,0）；
ﻩﻩexit（0）;
ﻩ}
}
ﻩeｌse
{
ﻩﻩwaｉt_ｍarｋ=１;
ﻩﻩｓｉgnal（１6,stop）;
sｉｇnal（SIGINT，ＳIＧ_ＩGＮ）；/＊忽略＾ｃ信号*/
ﻩｗhiｌｅ（waiｔ_mark!
=０）
ﻩlockｆ（１,1,０）；
ﻩprinｔf（"chｉｌdpｒoｃess１iskilleｄbyｐａreｎt!
\n＂）；
ﻩﻩlocｋf（1,0，0）；
eｘit（０）;
}
}
voiｄwaiｔing（）
{
sｌeeｐ（5）;
ｉｆ（wait_mark！
=０）
kiｌl（ｇeｔｐｉd（）,SIGALＲM）;
}
voidalarmiｎg（）
{
ﻩwait_mark=０;
}
voｉｄstop（）
｛
ﻩwaｉt＿mａｒｋ=0;
}
<运行结果〉
不做任何操作等待五秒钟父进程回在子进程县推出后退出，并打印退出的顺序;或者点击ｃtrｌ+C后程序退出并打印退出的顺序．
〈任务2〉
在上面的任务１中,增加语句sｉgnal（ＳIGINT,SIG＿IGN）和语句sｉgｎal（SＩGQUIT，SIG_ＩGN），观察执行结果,并分析原因。
这里，siｇnal（SＩＧIＮＴ,ＳＩG_IＧN）和ｓigｎaｌ（ＳIGQUIT，ＳIG＿ＩGN）分别为忽略键信号以及忽略中断信号。
<程序〉
＃ｉncｌudｅ<ｓtdio。
h〉
#include<ｓignaｌ.h〉
＃ｉnclｕｄe〈unistd.h〉
ﻩiｎtpｉd1,ｐid２;
intEndＦｌag=0;
ﻩintpｆ1=0;
int pf２=0；
ｖoidIｎtDelete（）
｛
kｉll（pid１,1６）;
kｉll（ｐiｄ2,１7）；
}
vｏidInt1（）
｛
printｆ（"cｈildｐrocess１iskilｌed!
bypａｒenｔ\ｎ"）；
ﻩexｉｔ（0）;
}
voiｄ Int２（）
｛
ﻩｐrinｔf（＂chilｄprｏcｅsｓ２ ｉs killed!
bypａrｅnt\n”）;
ﻩｅｘｉｔ（0）;
｝
ｍaｉn（）
{
ﻩintexitpid；
ﻩif（piｄ1＝foｒk（））
｛
ﻩif（pid2=foｒｋ（））
ﻩﻩ{
ﻩﻩsignaｌ（SIGＩNT，IｎtDeｌｅte）；
ﻩﻩﻩwaｉtpid（-1,&eｘｉｔpid,0）;
ﻩwaitpiｄ（—1，＆eｘitpiｄ,0）；
ﻩﻩｐriｎtf（"ｐareｎt ｐｒoｃｅｓｓiskｉlｌｅd\n”）；
ﻩｅxiｔ（０）;
ﻩ}
ﻩelse
ﻩﻩ ｛
ﻩｓiｇnａl（ＳIGINＴ,SIＧ_IＧN）；
ﻩsｉｇnaｌ（１7,Iｎｔ2）;
ﻩﻩpaｕse（）；
ﻩ}
ﻩ}
ﻩelｓe
{
ﻩﻩﻩｓigｎal（SIGINT,SIG_IGN）；
ﻩﻩsｉgnaｌ（１6,Int1）;
ﻩﻩﻩｐａuse（）;
｝
}
〈运行结果〉
请读者将上述程序输入计算机后,执行并观察.
3．进程的管道通信
〈任务〉
编制一段程序，实现进程的管道通信。
使用系统调用pipe（）建立一条管道线.两个子进程p１和p2分别向通道个写一句话：
child1prｏcｅssiｓseｎdingmessage！
cｈｉld2processissｅnｄinｇ meｓsage!
而父进程则从管道中读出来自两个进程的信息，显示在屏幕上。
<程序>
＃iｎclｕｄe#ｉnｃlude〈sｉgnal.h〉
#iｎclｕdｅ〈ｓtdｉo。
h〉
iｎtpｉd１,pｉd2;
mａin（）
{
iｎtfｄ［2];
ｃhar outpipe[100],inpipe[100］;
pｉpe（fd）； ／*创建一个管道*/
while（（piｄ１＝fｏrk（ ））=＝—１）；
iｆ（piｄ1==0）
{
lockf（fd［1]，1，0）;
sｐrintf（outpipe,"chilｄ1procｅss isｓenｄiｎgｍｅssaｇe!
＂）；
ﻩ／＊把串放入数组outpｉpe中*／
wrｉte（fd[1］,outpiｐｅ,5０）; /＊向管道写长为５０字节的串＊/
sleeｐ（5）; /*自我阻塞5秒＊/
loｃkf（fd［1],0,0）；
eｘit（0）；
｝
ｅlse
｛
while（（ｐid2＝ｆork（））==-1）;
if（pid2==0）
{
lockf（fd［1],1，0）； /＊互斥＊/
sprintf（outpiｐｅ，”child2 proceｓsiｓsendingmeｓsａge!
”）;
wｒite（fｄ[１]，ouｔpipe,5０）；
sｌeep（５）；
lｏｃｋf（fd[1]，0,０）;
eｘｉt（０）；
}
else
{
ｗaｉt（0）； /*同步＊/
ｒead（ｆｄ［0]，inpipｅ，5０）;/*从管道中读长为５０字节的串*／
printf（”%s＼n”，inｐiｐｅ）;
wait（０）;
reaｄ（fd[０]，iｎｐipe,5０）；
priｎtｆ（”%s\n＂,inpipe）；
eｘiｔ（0）;
｝
}
｝
〈运行结果〉
延迟5秒后显示：
ｃhild１proｃess ｉsｓendｉngmｅｓsａge!
ﻩ再延迟５秒:
ﻩｃhｉlｄ２ｐroceｓsissｅndｉngmesｓａge！
〈分析〉
请读者自行完成。
<思考〉
1、程序中的ｓleｅp（５）起什么作用?
ﻩ2、子进程1和２为什么也能对管道进行操作?
实验4指导
［实验内容]
1 消息的创建,发送和接收
〈任务＞
使用系统调用msggeｔ（）,mｅgsｎd（）,ｍｓgreｖ（ ）及ｍsgctl（）编制一长度为1Ｋ的消息发送和接收的程序.
〈程序设计〉
（1）为了便于操作和观察结果，用一个程序为“引子”,先后fork（ ）两个子进程，ＳERVER和CLIENT,进行通信.
（2）ＳERＶER端建立一个Ｋeｙ为7５的消息队列,等待其他进程发来的消息。
当遇到类型为1的消息,则作为结束信号，取消该队列,并退出SEＲVEＲ。
SEＲVEＲ每接收到一个消息后显示一句“（servｅｒ）received”。
（3）CLIＥNT端使用Key为7５的消息队列，先后发送类型从１0到1的消息,然后退出.最后的一个消息,既是SERVER端需要的结束信号。
ＣLIENT每发送一条消息后显示一句“（cliｅnｔ）sent”。
（4）父进程在SEＲVER和 ＣLＩENT均退出后结束。
〈程序〉
＃iｎcｌudeh＞
#incluｄeｈ〉
#include〈sys/ｍsｇ.h＞
#ｉncluｄeh〉
#ｄefineＭＳGＫEY ７5 /*定义关键词MEGKEY*/
ｓｔｒuct ｍsgfｏrm /*消息结构*／
{
ﻩlongｍtype;
ﻩcｈar mｔexe[10０］; /＊文本长度*/
}msg;
ｉntmsgｑｉd，i;
ｖoidＣＬIENT（）
｛
iｎti;
msgqid=msｇgｅt（MSGKEＹ,0777｜ＩＰＣ＿CRＥAＴ）;
ﻩfor（ｉ=１0;ｉ>=１;i－-）
ﻩ{
ﻩmsｇ.mtypｅ=ｉ；
ｐrintf（”（cｌiｅnt）seｎt\ｎ”）;
ﻩﻩｍsｇｓnd（mｓgｑid，&msｇ,1０30,0）; /*发送消息msg入msgｉd消息队列＊/
ﻩ}
exit（０）;
}
voｉdSＥRVＥＲ（）
｛
msｇqid=msggｅｔ（ＭＳGKEY,0７７７|IPC_ＣREＡT）;/＊由关键字获得消息队列*/
dｏ
{
msgrｃｖ（msgｑiｄ,＆msg,103０,０，0）;/*从队列ｍｓgｉd接受消息msg*/
ﻩ prｉnｔf（"（ｓeｒvｅr）receive\n”）;
｝whｉle（mｓg。
mtyｐe!
=１）; /＊消息类型为1时，释放队列＊/
msgｃtl（mｓgqiｄ,ＩPC＿RMIＤ,０）;
}
ｍain（）
{
ｉｆ（fｏrk（））
｛
SERＶER（）；
ﻩwait（0）;
}
elsｅCLＩENT（）;
}
〈结果＞
从理想的结果来说,应当是每当Client发送一个消息后,ｓerｖer接收该消息，Clｉent再发送下一条。
也就是说“（Clｉｅnｔ）ｓeｎt”和“（seｒｖｅr）rｅceived”的字样应该在屏幕上交替出现。
实际的结果大多是,先由Client发送两条消息,然后Serveｒ接收一条消息。
此后Cliｅｎt
Serveｒ交替发送和接收消息.最后一次接收两条消息。
Clｉｅnt 和Serｖer 分别发送和接收了10条消息,与预期设想一致
〈分析〉
message的传送和控制并不保证完全同步，当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象,在多次senｄmessage 后才ｒｅｃeivｅｍessage。
这一点有助于理解消息转送的实现机理.
２。
共享存储区的创建,附接和断接
〈任务＞
使用系统调用ｓｈｍgeｔ（）,ｓgｍａt（）,smｇｄt（）,ｓｈｍctl（）编制一个与上述功能相同的程序。
〈程序设计〉
（1）为了便于操作和观察结果，用一个 程序为“引子”,先后fｏｒk（）两个子进程,SERＶEＲ ﻩ和CLIＥNＴ，进行通信。
（2）SERVEＲ端建立一个KＥY为75的共享区,并将第一个字节置为—1。
作为数据空的标志.等待其他进程发来的消息。
当该字节的值发生变化时,表示收到了该消息,进行处理。
然后再次把它的值设为—1。
如果遇到的值为０，则视为结束信号,取消该队列，并退出SEＲVEＲ。
SERVＥR每接ﻩ收到一次数据后显示"（servｅｒ）receiveｄ”。
（3）ＣLＩENT端建立一个为75的共享区，当共享取得第一个字节为-1时， Seｒｖeｒ端空闲,可发送ﻩ请求。
CLIENＴ随即填入9到0.期间等待Ｓeｒvｅr端再次空闲.进行完这些操作后, CLＩENT ﻩ退出。
CLＩEＮT每发送一次数据后显示”（cｌient）sｅｎt＂。
（４）父进程在SERVＥR和CLＩEＮT均退出后结束。
<程序〉
#iｎｃlｕdｅ〈syｓ／ｔyｐｅs.h>
#iｎｃｌude〈sｙs/msg．h>
＃inｃlude〈sys/iｐc。
h〉
#dｅfineSHＭＫEＹ75 /*定义共享区关键词*/
iｎt shmｉd,i;
int ＊ａｄdr；
CLIENT（）
{ﻩ
ﻩinti;
sｈmid=shmget（SHMＫEY,1０24,０777|IPC_CREＡT）；／*获取共享区，长度1０2４，关键词SHMKEY＊/
addr=ｓｈｍａt（ｓhmｉd,0,0）; /*共享区起始地址为ａddr＊/ﻩ
fｏr（i=９;ｉ>=0；i——）ﻩ
{ﻩ
ﻩｗhｉlｅ（*addｒ!
=—1）; ﻩﻩ
ﻩｐrinｔｆ（”（clieｎt）ｓeｎt\n”）; /*打印（cｌieｎt）sent*/ﻩﻩ
ﻩ＊adｄr=ｉ； /*把ｉ赋给addr＊/ﻩ
ﻩ}ﻩ
eｘｉt（0）;
}
SERVＥR（）
{
ﻩdoﻩ
｛ﻩ
whiｌe（*ａddｒ==—１）;
priｎtｆ（"（sｅrｖer）recｅived\n％d”，＊addr）; /*服务进程使用共享区*／ﻩ
ｉｆ（＊adｄr!
＝0）
*ａddr=—1;ﻩ
ﻩ｝ while（＊aｄdr）；
waiｔ（0）；
ﻩshmｃtl（shmid，IPC＿RMＩD,0）;ﻩ
｝
ｍａin（）
｛
ﻩshmid=shmgeｔ（SHMKＥY，102４,0７7７|ＩPＣ_ＣREＡT）；/*创建共享区*/ﻩ
addr=shｍat（ｓhmｉd,0，0）; /*共享区起始地址为ａｄｄr＊／ﻩ
*addr=—1;ﻩ
ﻩiｆ（fork（））
ﻩ｛
SERＶER（）；
ﻩ}
ﻩeｌｓe
{
CLIENT（）;
}
}
<结果〉
运行的结果和预想的完全一样。
但在运行的过程中,发现每当clieｎt发送一次数据后,servｅr要等大约0.1秒才有响应。
同样，之后clieｎt又需要等待大约０.1秒才发送下一个数据.
<分析〉
出现上述的应答延迟的现象是程序设计的问题．当ｃliｅnt端发送了数据后,并没有任何措施通知ｓeｒver端数据已经发出,需要由clieｎt的查询才能感知。
此时，clieｎt端并没有放弃系统的控制权,仍然占用CPU的时间片.只有当系统进行调度时，切换到了seｒver进程,再进行应答。
这个问题，也同样存在于sｅrｖeｒ端到ｃｌiｅｎt的应答过程之中。
3比较两种消息通信机制中的数据传输的时间
ﻩ 由于两种机制实现的机理和用处都不一样，难以直接进行时间上的比较。
如果比较其性能，应更加全面的分析。
（1）消息队列的建立比共享区的设立消耗的资源少。
前者只是一个软件上设定的问题,后者需要对硬件操作,实现内存的映像,当然控制起来比前者复杂．如果每次都重新进行队列或共享的建立,共享区的设立没有什么优势。
（2）当消息队列和共享区建立好后,共享区的数据传输，受到了系统硬件的支持,不耗费多余的资源;而消息传递,由软件进行控制和实现,需要消耗一定的CPＵ资源.从这个意义上讲，共享区更适合频繁和大量的数据传输。
（3）消息的传递,自身就带有同步的控制.当等到消息的时候，进程进入睡眠状态,不再消耗CPＵ资源.而共享队列如果不借助其他机制进行同步,接受数据的一方必须进行不断的查询,白白浪费了大量的CPU资源.可见消息方式的使用更加灵活。
实验5指导
［实验内容]
<任务〉
设计一个虚拟存储区和内存工作区,并使用下列算法计算访问命中率.
（1）进先出的算法（ＦIFO）
（2）最近最少使用的算法（LRU）
（3）最佳淘汰算法（OPT）
（4）最少访问页面算法（ＬＦU）
（5）最近最不经常使用算法（ＮＵR）
命中率=（1-页面失效次数）/页地址流长度
〈程序设计>
ﻩ本实验的程序设计基本上按照实验内容进行。
即首先用sｒaｎd（）和ｒａnd（）函数定义和产生指令序列,然后将指令序列变换成相应的页地址流,并针对不同的算法计算出相应的命中率。
相关定义如下:
1数据结构
ﻩ
（1）页面类型
typedeｆｓtrｕct｛
intpn，pfn，cｏuntｅr,tiｍe;
}pl—type;
其中pn为页号，pfｎ为面号，couｎter为一个周期内访问该页面的次数，ｔimｅ为访问时间。
（２） 页面控制结构
pｆc—sｔｒuｃｔ{
intｐn,pfn；
strｕctpfｃ_stｒuｃt＊nexｔ；
}
ｔypedef struct pfｃ_struct ｐfc_tyｐe;
pfc_typepｆc_struｃｔ[ｔｏtal＿vp],*freepf＿hｅad,*ｂusｙpf＿hｅad;
pfc＿tyｐe*busypf_ｔaiｌ；
其中pｆc[toｔａl_vp]定义用户进程虚页控制结构,
*ｆreepｆ_heaｄ为空页面头的指针,
*busyｐｆ＿hｅad为忙页面头的指针,
＊busypf＿tail为忙页面尾的指针。
2.函数定义
（1）
升级会员 