读者写者实验报告

时间：2020-10-23 12:09:56 来源：蒲公英阅读网 本文已影响人

相关热词搜索：读者 实验 报告

　操作系统原理

　实验报告

　实验名称: :

　操作系统

　姓

　名: :

　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; }