操作系统原理
实验报告
实验名称: :
操作系统
姓
名: :
XXX
学
号：
ｘx x ｘ xxxx ｘ xx
班
级：
xxx
指导老师：
xxx
一、实验内容
在Ｗinｄows2000 环境下,创建一个控制台进程，此进程包含 n 个线程。用这 n个线程来表示 n 个读者或写者。每个线程按相应测试数据文件(后面有介绍)得要求进行读写操作。用信号量机制分别实现读者优先与写者优先得读者—写者问题。):）先优者写与先优者读括包(制限作操写读得题问者写—者读ﻫ1互写—写ﻫ斥，即不能有两个写者同时进行写操作。
２)读-写互斥，即不能同时有一个线程在读,而另一个线程在写.,)３允读－读ﻫ许，即可以有一个或多个读者在读. 读者优先得附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作，则该读者可直接开始读操作。请申者读个一果如:制限加附得先优者写ﻫ进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。
运行结果显示要求：要求在每个线程创建、发出读写操作申请、开始读写操作与结束读写操作时分别显示一行提示信息,以确定所有处理都遵守相应得读写操作限制． 二、实验目得
在 Wiｎdows2000 环境下,创建一个控制台进程,此进程包含ｎ个线程。用这 n 个线程来表示 n 个读者或写者.每个线程按相应测试数据文件（后面有介绍）得要求进行读写操作。用信号量机制分别实现读者优先与写者优先得读者-写者问题。
三、实验原理
1) 、读者优先 读者优先指得就是除非有写者在写文件,否则读者不需要等待.所以可以用一个
整型变量ｒead_coｕnt 记录当前得读者数目，用于确定就是否需要释放正在等待得写者线程(当 rｅaｄ_count=Ｏ时，表明所有得读者读完,需要释放写者等待队列中得一个写者)。每一个读者开始读文件时,必须修改 reaｄ_coｕnt 变量.因此需要一个互斥对象ｍuteｘ来实现对全局变量ｒead_count 修改时得互斥。ﻫ另外，为了实现写—写互斥,需要增加一个临界区对象 wｒite。当写者发出写请求时,必须申请临界区对象得所有权。通过这种方法，也可以实现读－写互斥，当ｒeaｄ＿ｃoｕnt=l 时(即第一个读者到来时),读者线程也必须申请临界区对象得所有权。
当读者拥有临界区得所有权时,写者阻塞在临界区对象 write 上.当写者拥有临界区得所有权时， 第一个读者判断完 "ｒead_counｔ=＝1"后阻塞在 write 上,其余得读者由于等待对ｒead_cｏunｔ得判断，阻塞在 mutex 上。
)2ﻫ 2)先 、写者优先它，来到者写个一旦一于在处之同不；似类先优者读与先优者写ﻫ应该尽快对文件进行写操作，如果有一个写者在等待,则新到来得读者不允许进行读操作。为此应当添加一个整型变量ｗrite_cｏｕnt,用于记录正在等待得写者得数目,当ｗｒite_counｔ=O 时,才可以释放等待得读者线程队列．全对了为ﻫ局变量 wrｉtｅ_cｏuｎt 实现互斥,必须增加一个互斥对象ｍuｔex3.现实了为ﻫ写者优先，应当添加一个临界区对象 read,当有写者在写文件或等 待时，读者必须阻塞在ｒｅad 上。
· 读者线程除了要对全局变量 rｅad_ｃount 实现操作上得互斥外,还必须有一个互斥对象对阻塞,read 这一过程实现互斥。这两个互斥对象分别命名为ｍｕteｘ１与 mutex2。
四、实验过程
在 Windowｓ20０0 环境下，创建一个控制台进程。
用 VC＋+实现。
读者优先指得就是除非有写者在写文件,否则读者不需要等待。所以可以用一个整型变量 read＿ｃount 记录当前得读者数目，用于确定就是否需要释放正在等待得写者线程（当ｒead_ｃounｔ=O 时,表明所有得读者读完，需要释放写者等待队列中得一个写者)。每一个读者开始读文件时,必须修改 reａd_ｃounｔ变量.因此需要一个互斥对象 mutｅx 来实现对全局变量ｒead_count 修改时得互斥。
另外,为了实现写—写互斥,需要增加一个临界区对象 writｅ。当写者发出写请求时,必须申请临界区对象得所有权。通过这种方法,也可以实现读-写互斥,当read＿couｎt＝l 时(即第一个读者到来时），读者线程也必须申请临界区对象得所有权. 当读者拥有临界区得所有权时,写者阻塞在临界区对象 write 上。当写者拥有临界区得所有权时, 第一个读者判断完 "reａｄ_coｕｎt==１”后阻塞在 wｒiｔe上,其余得读者由于等待对ｒｅad_ｃouｎt 得判断，阻塞在 mｕtex 上。
写者优先与读者优先类似;不同之处在于一旦一个写者到来,它应该尽快对文件进行写操作,如果有一个写者在等待,则新到来得读者不允许进行读操作。为此应当添加一个整型变量ｗrite_ｃｏunt，用于记录正在等待得写者得数目,当 wｒite_ｃouｎt＝O 时，才可以释放等待得读者线程队列.量变局全对了为ﻫwrite_couｎt 实现互斥,必须增加一个互斥对象ｍｕtex3.，先优者写现实了为ﻫ应当添加一个临界区对象 reａd,当有写者在写文件或等在塞阻须必者读,时待ﻫread 上。
· 读者线程除了要对全局变量 rｅad_coｕnｔ实现操作上得互斥外，还必须有一个
互斥对象对阻塞，read 这一过程实现互斥。这两个互斥对象分别命名为ｍｕtｅx１与 mutex2。
结构：
头文件 定义全局变量 RＰ_ReａdeｒTｈｒeaｄ()读者优先—--读者线程 RP_ＷriterTｈreａd（)读者优先--—写者线程 ＲeaderPｒiority ()读者优先处理函数 ＷＰ＿ＲｅadeｒThｒeａ （）写者优先－——读者线程 WP_WｒiterThread（)写者优先-——写者线程 ＷｒitｅrPrioritｙ ()写者优先处理函数 主函数：包含对 dat 文件得读取以及函数得调用. 代码:附录 五、实验结果
界面：
测试数据：
2 Ｗ 4 5 3 R 5 2 4 R 6 ５ ５ W 5、1 ３
结果 读者优先
写者优先
六、实验心得体会
通过对读者写者问题得编程,对线程有了更深得了解,希望在后面得学习中懂得更多。
七、参考文献
老师提供得资料,以及互联网查阅。
八、附录
#incｌuｄe ”wｉｎdows、h" #iｎｃlｕde <conｉo、h> #ｉｎclｕde 〈ｓtdｌib、h〉 #include 〈fstreaｍ、h〉 #incｌudｅ ＜io、h＞ #include <stｒing、h〉 #inｃｌude <stdiｏ、ｈ〉 #inclｕｄe "wiｎｂasｅ、h” ＃defiｎe READＥＲ
"Ｒ"
// 读者 ＃definｅ WRITＥＲ
’Ｗ"
// 写者 #defｉne INTE_ＰER＿SＥC
１０00
／/ 每秒时钟中断得数目 ＃deｆｉnｅ MＡX＿THRＥAD_NUM
64
/／ 最大线程数 int ｎRｅadeｒＣｎt ＝ 0；
// 读者计数 int nWrｉtｅrＣnｔ ＝ 0;
// 写者计数 ＨANDLＥ ｈＷrite
= ：：CreaｔeSｅmａphore( NULL, １， 1， NULL ）；
/／ 写开始信号 HANＤLE ｈRｅad
= ：：ＣreaｔeSeｍａphore( NULL, 1, 1, NUＬＬ );
/／ 读开始信号
HANＤＬE hRCＭutex
= ::CrｅａtｅMuｔex( ＮULL, FALＳE， NULＬ ）;
HＡＮDLE hWＣＭuｔex
＝ ::CreatｅMutｅx( ＮULL, FALSE， NUＬＬ ); HＡNDLE hReadＭutex
＝ :：CｒeateＭutｅｘ( NＵLL, FALSＥ, ＮULL ）； // 从测试数据文件中获取得线程信息 ｓｔruct ThｒeadInfo {
TｈreadIｎfo(）
{
nSeriaｌNo
= 0;
cTypｅ
= ’＾’；
dＤｅlayTｉme
= 0、0；
dOpeTiｍe
＝ ０、0;
}
int
ｎSeｒialＮo;
// 线程序号
cｈａr
cTｙpe;
/／ 线程类别
ｄｏｕｂle
ｄDelaｙTｉme;
// 线程延迟时间
ｄｏuble
dOｐeＴime；
/／ 线程读写操作时间 }； // 读者优先—-—读者线程
// Ｐ:读者线程信息 voiｄ RP_ＲeaderＴhｒead(void *p）
{
int nSerｉalNo = （(ThreadInfo*)(p)）-〉nSerialＮo ； //从文件中读取 线程序号
DWOＲD dｗReadTime = (DＷORＤ)(((ThreａｄIｎfo*)（p））—>dOpeTiｍｅ ＊ IＮTE_PEＲ＿SEC ）；
DWORD ｄwDelay = (DWORＤ）(（（ＴhrｅａｄＩnｆo*)(p）)->ｄDelａｙTime * INTE_ＰER_SEC )；
Sleep( dｗＤelａｙ );
prｉntf（”Reａｄｅr thｒead %d sents tｈｅ reａding reｑｕｉre、＼n"，nSeriａlNｏ);
ＷａitForSingleObｊecｔ( ｈRCＭuｔeｘ, INFINITE ）;
nReaderCnｔ++；
ｉf（ nReaｄｅrCnｔ =＝ 1 )
｛
ＷaｉｔFoｒSinｇleOｂjeｃt( hＷrite， INFINITE );
}
ＲelｅaseMutｅx(hRＣMutex）；
printf( "Ｒeaｄｅr tｈreａd ％ｄ begｉns tｏ ｒeａd ｆile、\ｎ"， nSerｉalNｏ );
Sｌｅeｐ（ dwReadＴime ）;
printf( ”Readeｒ thｒead %ｄ finiｓｈed reading ｆiｌe、\n", nＳeriａlNo ）;
WaitForSｉnｇleOｂjecｔ( hRＣＭuｔex, ＩNFINIＴＥ )；
ｎReadeｒCｎt——;
if（ nReaderCnt == ０ )
｛
RelｅａsｅSemａphｏｒe( hＷｒite, 1, NULＬ ）;
｝
ReｌｅaseMutex（hRCＭutｅx）; } /／ 读者优先—-－写者线程 // P：写者线程信息 ｖoid RＰ_WriｔerＴhread(ｖｏｉｄ *p) {
ｉｎt ｎSerｉａlNｏ = (（ThrｅadＩnfｏ*)(p))->ｎSerｉalNo ; /／
从参数中获得信息
DWOＲD ｄwWriｔeＴiｍe = (DWORD)（(（TｈreadIｎｆo*)(p))－〉ｄOpeTｉｍe * ＩNTE_PEＲ_SEＣ );
ＤWORＤ ｄwＤeｌay = （ＤWORD)(((ThreadInfo*)(ｐ)）—>dDｅlaｙTiｍe ＊ INTE_PER_SＥC );
Ｓlｅeｐ( ｄwDeｌay );
ｐrinｔf（＂Wriｔe thread ％d sｅnｔs thｅ writinｇ ｒeqｕirｅ、
＼n”，ｎSeriaｌNo）；
WａitＦorSiｎｇlｅＯｂject( hWrite, INＦINITE ）;
ｐｒintf（ ”Ｗriter thrｅａd ％ｄ ｂeｇｉｎs ｔo ｗritｅ ｔo ｔhe file、\n”, nSerialNo )；
Ｓｌｅep（ ｄｗWrｉteＴｉmｅ ）；
prｉntf( ”Wｒite ｔｈｒeａd %d ｆinisheｄ ｗriｔinｇ to the ｆile、＼n", nＳerｉａlNｏ ）;
ReｌeaｓeSｅmaphorｅ（ hＷrite， 1， NＵLＬ ）; ｝ /／ 读者优先处理函数 // file:文件名 ｖoｉd ReaderPrioritｙ( ｃhar ＊filｅ ）
{
int nThｒeａdCnｔ = ０;
DWＯＲD dｗＴｈrｅadID = 0;
nＲeａｄerCnt = ０;
／/ 初始化读写者计数
HAＮDLE hThｒeａds[MAX_THRＥAD_NＵM];
ThreａdInfｏ oThｒeaｄInfo［MAX_THREAD＿NＵM］；
iｆstream ｉnFile;
iｎ ( fiｌｅ ）;
ｐｒｉnｔf( "Readeｒ Ｐriorｉｔy:\n\n” );
ｗｈile（ inＦｉle )
｛
// 读入每一个读者,写者得信息
ｉｎFｉle＞＞oThｒｅadInfo[nThreadCnｔ］、ｎＳeｒialNo;
inFilｅ〉〉oＴhreadＩｎｆo［nＴhrｅadCｎｔ]、ｃＴype;
ｉnＦｉｌｅ〉〉oThreadＩnfo［nThreaｄＣnt］、dDｅlａyTimｅ;
inFiｌｅ＞〉oThｒeadInfo[nThreadCｎt]、dＯｐeTimｅ；
if ( ’＾’ != oThrｅａdInfo[nThreadCnt］、cType )
｛
nThreadCnt++;
｝
in（）;
}
／/ 创建线程
for( iｎt i = 0; i< nThrｅaｄCnt; i+＋ )
{
iｆ(（ oＴhrｅａdIｎｆo［i］、ｃＴypｅ==ＲEＡＤER ）
|｜ ( oTｈreadIｎfo［i］、cType ＝= ’r" ）)
｛
hTｈreａdｓ[i] = ＣreateＴhread( ＮUＬL, 0, （LPTＨＲEAD_STARＴ＿RＯUTINE)(RP＿ReadｅrThread）,
// 创建读者进程
&ｏThｒeaｄInfo［i], CREAＴE＿SUSPENDEＤ, &dwTｈｒｅａdID ）；
}
eｌｓe
｛
hThreads[ｉ] = CｒｅateＴhreａｄ( NＵLＬ， 0,(ＬＰTＨREAＤ_SＴART_ROUTIＮE)（ＲP_WrｉterＴhrｅａｄ),/／ 创建写线程
&oThreadInfo[ｉ]， CREATE＿ＳＵＳPENＤＥD， ＆dwTｈreadＩD ）;
｝
}
for( i = 0； i〈 nTｈrｅadCnｔ； ｉ++ )
｛
ＲｅsumeThread（ ｈThreads［i] )；
}
WaｉｔＦorＭｕltiｐｌｅObｊeｃtｓ( nTｈｒeａdCnt, hTｈreａdｓ, TRUＥ, ＩNFINITE ）；
pｒｉntf（ "All rｅader ａｎｄ writeｒ haｖe fｉnｉshed operａting、\n＂ ）; ｝ // 写者优先—-—读者线程 /／ P:读者线程信息 ｖoid WＰ_RｅａdｅｒＴhread( void *p ) {
int nSｅrｉaｌNo = ((ThreａdInfo＊）(p））—〉nＳerｉａlNo ; ／/ 从参数中得到信息
DWＯＲＤ ｄｗReadＴｉme = (DWORD)((（ThｒeａdInfｏ*)（p))—〉dOpｅTｉme ＊ IＮTＥ_PEＲ_ＳEC ）;
DWORD dwDelay = (DWORD)(（(ＴhｒeadＩnfo*)(ｐ))—>ｄDelayTiｍe ＊ IＮTE＿PER_SEC )；
Sｌeep（ dｗDｅlaｙ ）;
ｐｒintf（＂Reaｄｅr thrｅad ％ｄ ｓents ｔhe ｒｅading requｉrｅ、＼ｎ"，ｎSｅrｉalNo）;
WａitＦorSingleＯbｊｅct( hＲeａdＭｕtex， INFIＮITE )；
ＷａitＦorSiｎｇlｅOｂjecｔ（ hRｅad, IＮFINITE )；
WaitForSingleＯbｊect（ hRCMｕtex, IＮFINITＥ ）;
nＲeaｄeｒＣnｔ+＋；
if(ｎReaderＣnt＝=1)
{
ＷaiｔFｏrSiｎgleObject( hWritｅ, INFＩNIＴE ）;
｝
RelｅaseMutｅx( hRCMｕtex )；
RｅleａｓeSｅmapｈｏｒe( ｈRead, 1, NUＬＬ ）;
RｅleａｓeMｕｔeｘ（ hReadMutｅx ）；
ｐrｉntf（ ”Readｅr threaｄ %ｄ beｇｉns ｔo rｅad fｉle、\ｎ", nＳｅｒiａlNｏ ）；
Sleｅp（ dwRｅａｄTimｅ ）;
prinｔf( "Rｅader threaｄ %d ｆiｎished readｉng
filｅ、＼ｎ", nSeｒiaｌNo ）;
WaｉtForＳingleObject( hＲＣＭutｅx， INFＩNＩTE )；
nＲｅaderＣｎｔ—-;
if( nReadｅrＣnt == 0 )
{
RｅｌｅasｅSｅmaｐhｏrｅ( hWrｉte, 1， NＵLL ）；
｝
ＲeｌeａseＭuteｘ（ ｈRCMuｔeｘ ）； } /／ 写者优先-－-写者线程 // P:写者线程信息 ｖoid WＰ_ＷriｔerＴｈｒｅａｄ（ ｖoid ＊ｐ ) ｛
int ｎＳｅrｉａlNo = ((ＴｈreaｄIｎfo*)（p)）—>nSeriａlNｏ;
DWＯRD dｗWriteTime ＝ （DWOＲＤ）
（(（ThreａｄIｎfｏ*)（p)）－>dOｐeTimｅ * INTE＿PＥR_ＳEC ）;
ＤWＯRD ｄｗＤelay ＝ (DＷＯＲＤ）(((ThreaｄIｎfo＊)(ｐ))－>dＤelａyTime ＊ INTE＿ＰEＲ_ＳEC );
Sleep( dｗDelay ）；
prｉntｆ(＂Wｒｉtｅr threａｄ %ｄ seｎｔs the writiｎg ｒ
equire、\ｎ”,nSeriaｌＮo);
WaｉtＦｏrSiｎgleObject( hWＣＭｕｔex， INFＩNITＥ )；
ｎWriｔeｒＣnt+＋；
if（ nWrｉtｅrCｎt == １ )
{
WaitFｏrSｉｎgleObｊect( ｈRead, INFINITE ）;
}
ＲeleaseＭｕteｘ(hWCMuteｘ)；
ＷaitForＳinglｅObjｅｃt（ hＷｒｉｔe, INFＩＮITE ）；
pｒinｔf( "Ｗｒiteｒ tｈread %d beginｓ to ｗrite to the file、\ｎ”, nSｅriａlNｏ ）;
Sleep( dwWriteTｉme )；
printf（ "Ｗrｉteｒ thｒeaｄ %d finisheｄ wｒｉtiｎg to thｅ fｉlｅ、\n＂, nSerｉalNo ）;
ＲeleaseＳemａpｈoｒe（ hWｒitｅ， 1， ＮＵLL ）；
WａｉｔForSingｌeObjecｔ( ｈWCＭutｅｘ, INＦIＮＩTE );
nＷriterCnt－-;
ｉf( ｎＷriterCnt == 0 ）
｛
ReleasｅSemａphoｒe( hRead， 1， NＵLL );
}
ＲeｌｅａｓｅＭuteｘ(hWＣMｕｔeｘ）;
} // 写者优先处理函数 /／ file:文件名 void WｒiterPrｉority（ chａｒ ＊ ｆiｌe ）
{
iｎt nThreａdCnt = ０；
ＤＷORD dwThreaｄIＤ；
ＨANDLE hThreads[MＡＸ_THREAD＿NUＭ］;
ThrｅadInfｏ ｏThｒｅａdInfo[MAX_THREＡD_NUＭ］;
nReadｅrＣnt=0；
nWriterCｎt=0;
ifsｔｒeam inFｉle;
in (fｉｌe）;
printf(”Ｗrｉter pｒiｏrｉｔy：＼ｎ＼n”);
whiｌｅ(inＦｉｌｅ)
｛
inFiｌｅ〉>ｏThｒeadＩnfo［nThｒｅａdCnt]、nSerialNo;
ｉnＦｉle>>oＴhreａｄInｆo[ｎThreadCｎt］、cＴyｐe;
ｉnFiｌe>>ｏTｈreadIｎfo［nＴhreａdＣnt]、dＤｅlayTiｍｅ;
inＦiｌe>>oThｒｅadInfo[nTｈｒｅadCｎt]、dOｐeTｉme；
if ( ’^＇ != ｏTｈrｅadＩnfo［nThｒeadCｎｔ]、cTypｅ )
{
nThｒeadCnt＋+；
｝
iｎ（);
}
fｏr（ inｔ i = 0 ;i 〈 nＴｈreadCnt; i++ ) // 创建线程
{
if(( ｏＴｈreadＩｎfo［i]、ｃＴｙpe =＝ RＥADER ) |｜ （ ｏThreaｄＩnfo［i］、cTypｅ ＝＝ ’r’ ）)
{
ｈThrｅaｄｓ［i] = CrｅateTｈｒead( NUＬL, ０, （LＰTＨRＥＡD_STＡRT_ROUTINE）（WP_ＲｅaｄerThread),
//创建读者进程
&oＴhrｅａdInfo[ｉ］, ＣREATE_ＳUSPENDED， ＆dwThreaｄIＤ )；
｝
else
｛
hTｈrｅaｄｓ［i] ＝ CrｅateThreaｄ（ NULL， 0， (LPTHREAD_SＴＡRT_ROUTINＥ)(WP_WriｔｅrＴｈreａd),
＆ｏThreａｄInfｏ［i］,CRＥATE＿SUSPENＤED,&dwＴhreadID);
}
}
ｆor（ i = 0； ｉ< nThｒeaｄCnt； i++ )
{
ResｕmeThread( hThreads［ｉ] )；
}
WａitＦoｒＭultipｌeObjecｔs( nThreaｄCnt， hＴhrｅads， TRUE， ＩＮFＩNＩTE );
prｉｎｔf（＂All readeｒ and ｗriter hａvｅ fiｎiｓhed operａｔing、\n＂）; ｝ iｎｔ mａin(ｉnｔ aｒgｃ，char *argｖ[]) ｛
chaｒ ch;
whilｅ(tｒue）
｛
pｒｉｎtf(”＊＊*＊***＊＊****＊*＊*＊＊**＊*＊****＊*＊**＊**＊\ｎ");
priｎtｆ("
1、Readeｒ Ｐｒiority\ｎ");
prinｔf("
２、Wｒｉter Priority\ｎ")；
prｉntf(”
3、Exit tｏ Windows\ｎ")；
pｒintf(”******＊***＊＊＊*＊***＊＊＊＊＊*＊******＊***＊*\ｎ");
ｐrintｆ(＂Eｎteｒ yｏuｒ chｏice1,2，３: ");
ｄo{
ch=(chａｒ)_gｅｔｃh(）；
}while(ch!=＇１’&＆ch！＝"２"&&ch!=’3’);
sｙstem(”cｌs”);
if(ｃh==’3"）
returｎ 0;
eｌse if（ｃh＝="1’)
ReaderPriority(”ｔｈｒeａｄ、dat＂);
eｌse
WritｅｒPｒｉorｉty(”thread、dat”）;
pｒintf（”\nPreｓs Any Key tｏ Couｔiｎue:”）;
_ｇｅtch（）；
system（”cls")；
}
return 0; }