操作系統課程設計---讀者-寫者問題實現

上傳人：奔*** IP屬地：河北更新時間：2024-03-01 格式：doc 頁數：19 大?。?05.00KB 人氣指數：12 舉報 版權申訴

已閱讀1頁，還剩18頁未讀，繼續(xù)免費閱讀

版權說明：本文檔由用戶提供并上傳，收益歸屬內容提供方，若內容存在侵權，請進行舉報或認領

文檔簡介

1、　　操作系統課程設計報告　　一、操作系統課程設計任務書　　讀者-寫者問題實現　　設計目的　　通過實現經典的讀者寫者問題，鞏固對線程及其同步機制的學習效果，加深對相關基本概念的理解

2、，并學習如何將基本原理和實際設計有機的結合。　　2 設計內容　　在Windows 2000/XP環(huán)境下，使用多線程和信號量機制實現經典的讀者寫者問題，每個線程代表一個讀者或一個寫者。　　每個線程按相應測試數據文件的要求，進行讀寫操作。請用信號量機制分別實現讀者優(yōu)先和寫者優(yōu)先

3、的讀者-寫者問題。　　讀者-寫者問題的讀寫操作限制：　　(1)寫-寫互斥，即不能有兩個寫者同時進行寫操作　　(2)讀-寫互斥，即不能同時有一個讀者在讀，同時卻有一個寫者在寫　　(3)讀-讀允許，即可以有二個以上的讀者同時讀　　讀者

4、優(yōu)先的附加限制：如果一個讀者申請進行讀操作時已有另一讀者正在進行讀操作，則該讀者可直接開始讀操作。　　寫者優(yōu)先的附加限制：如果一個讀者申請進行讀操作時已有另一寫者在等待訪問共享資源，則該讀者必須等到沒有寫者處于等待狀態(tài)后才能開始讀操作。　　運行結果顯示要求：要求在每個線程創(chuàng)建、發(fā)出讀寫操作申請、開始讀寫操作和結束讀寫操作時分別顯示一行提示信息，以確信所有

5、處理都遵守相應的讀寫操作限制。　　3 測試數據文件格式　　測試數據文件包括n 行測試數據，分別描述創(chuàng)建的n 個線程是讀者還是寫者，以及讀寫操作的開始時間和持續(xù)時間。每行測試數據包括四個字段，各字段間用空格分隔。第一字段為一個正整數，表示線程序號。第二字段表示相應線程角色，R 表示讀者是，W 表示寫者。第三字段為一個正數，表示讀寫操作的開始時間。線程創(chuàng)建

6、后，延時相應時間（單位為秒）后發(fā)出對共享資源的讀寫申請。第四字段為一個正數，表示讀寫操作的持續(xù)時間。當線程讀寫申請成功后，開始對共享資源的讀寫操作，該操作持續(xù)相應時間后結束，并釋放共享資源。下面是一個測試數據文件的例子：　　1 R 3 5　　2 W 4 5

7、　　3 R 5 2　　4 R 6 5　　5 W 5.1 3　　4 相關API函數　　CreateThread()在調用進程的地址空間上創(chuàng)建

8、一個線程　　ExitThread()用于結束當前線程　　Sleep()可在指定的時間內掛起當前線程　　CreateMutex()創(chuàng)建一個互斥對象，返回對象句柄　　OpenMutex()打開并返回一個已存在的互斥對象句柄，用于后續(xù)訪問

9、;　　ReleaseMutex()釋放對互斥對象的占用，使之成為可用　　WaitForSingleObject()可在指定的時間內等待指定對象為可用狀態(tài)　　InitializeCriticalSection()初始化臨界區(qū)對象　　EnterCriticalSection()等待指定臨界區(qū)對象的所有權</p&

10、gt;　　LeaveCriticalSection()釋放指定臨界區(qū)對象的所有權　　二、設計思路　　將所有的讀者和所有的寫者分別放進兩個等待隊列中，當讀允許時就讓讀者隊列釋放一個或多個讀者，當寫允許時，釋放第一個寫者操作。　　讀者優(yōu)先：

11、 　　如果沒有寫者正在操作，則讀者不需要等待，用一個整型變量readcount記錄當前的讀者數目，用于確定是否釋放寫者線程，（當readcout=0 時，說明所有的讀者都已經讀完，釋放一個寫者線程），每個讀者開始讀之前都要修改readcount,為了互斥的實現對readcount 的修改，需要一個互斥對象Mutex來實現互斥。　　另外

12、，為了實現寫-寫互斥，需要一個臨界區(qū)對象 write,當寫者發(fā)出寫的請求時，必須先得到臨界區(qū)對象的所有權。通過這種方法，可以實現讀寫互斥，當readcount=1 時，（即第一個讀者的到來時，），讀者線程也必須申請臨界區(qū)對象的所有權.　　當讀者擁有臨界區(qū)的所有權，寫者都阻塞在臨界區(qū)對象write上。當寫者擁有臨界區(qū)對象所有權時，第一個判斷完readcount==1 后，其余的讀者由于等待對rea

13、dcount的判斷，阻塞在Mutex上！　　寫者優(yōu)先：　　寫者優(yōu)先和讀者優(yōu)先有相同之處，不同的地方在：一旦有一個寫者到來時，應該盡快讓寫者進行寫，如果有一個寫者在等待，則新到的讀者操作不能讀操作，為此添加一個整型變量writecount,記錄寫者的數目，當writecount=0時才可以釋放讀者進行讀操作！為了實現

14、對全局變量writecount的互斥訪問，設置了一個互斥對象Mutex3。　　為了實現寫者優(yōu)先，設置一個臨界區(qū)對象read,當有寫者在寫或等待時，讀者必須阻塞在臨界區(qū)對象read上。　　讀者除了要一個全局變量readcount實現操作上的互斥外，還需要一個互斥對象對阻塞在read這一個過程實現互斥，這兩個互斥對象分別為mutex1和mutex2。<

15、/p>　　程序結構　　主要代碼進行分析：　　1、臨界區(qū)：　　CRITICAL_SECTION RP_Write; //臨界區(qū)　　C

16、RITICAL_SECTION cs_Write;　　CRITICAL_SECTION cs_Read;　　臨界區(qū)（Critical Section）是一段獨占對某些共享資源訪問的代碼，在任意時刻只允許一個線程對共享資源進行訪問。如果有多個線程試圖同時訪問臨界區(qū)，那么在有一個線程進入后其他所有試圖訪問此臨界區(qū)的線程將被掛起，并一直持續(xù)到進入臨界區(qū)的線程離

17、開。臨界區(qū)在被釋放后，其他線程可以繼續(xù)搶占，并以此達到用原子方式操作共享資源的目的。　　臨界區(qū)在使用時以CRITICAL_SECTION結構對象保護共享資源，并分別用EnterCriticalSection（）和LeaveCriticalSection（）函數去標識和釋放一個臨界區(qū)。所用到的CRITICAL_SECTION結構對象必須經過InitializeCriticalSection（）的初

18、始化后才能使用，而且必須確保所有線程中的任何試圖訪問此共享資源的代碼都處在此臨界區(qū)的保護之下。否則臨界區(qū)將不會起到應有的作用，共享資源依然有被破壞的可能。　　2、定義線程結構:　　struct ThreadInfo 　　{int Threadha

19、o; 　　char ThreadClass; 　　double ThreadStartTime; 　　double ThreadRunTime; 　　};&

20、lt;p>　　此結構用來存放線程的信息,四個成員變量依次表示線程序號、線程類別、線程開始時間、線程讀寫持續(xù)時間。　　3、互斥對象　　創(chuàng)建互斥對象　　CreateMutex(NULL,FALSE,"mutex_for_rea

21、dcount");　　參數含義如下：　　NULL表示創(chuàng)建帶有默認安全性的內核對象　　FALSE表示該互斥對象沒有被任何線程所擁有　　mutex_for_readcount是為內核對象賦予名字。<

22、p>　　釋放互斥信號　　ReleaseMutex(h_Mutex); 　　對資源具有訪問權的線程不再需要訪問此資源而要離開時，必須通過ReleaseMutex（）函數來釋放其擁有的互斥對象　　4、創(chuàng)建讀者線程

23、　　CreateThread(NULL,0,\(LPTHREAD_START_ROUTINE)(R_ReaderThread),　　\&thread_info[i],0,&thread_ID);　　參數含義如下：　　NULL表示創(chuàng)建帶有默認安

24、全性的內核對象　　0表示新讀者線程擁有自己的堆棧，使用缺省大?。?MB。 　　(LPTHREAD_START_ROUTINE)(R_ReaderThread)表示新讀者線程執(zhí)行的線程函數的地址　　&thread_info[i]表示在線程啟動執(zhí)行時將該參數傳遞給讀者線程函數。<

25、p>　　0表示讀者線程創(chuàng)建后可以立即進行調度　　&thread_ID表示CreateThread使用這個地址來存放系統分配　　給新讀者線程的I D　　5、等待函數　　WaitForMultipleObjects(n_th

26、read,h_Thread,TRUE,-1);　　等待函數可使線程自愿進入等待狀態(tài)，直到一個特定的內核對象變?yōu)橐淹ㄖ獱顟B(tài)為止　　參數含義如下：n_thread表示線程數量。　　h_Thread是指向線程對象句柄的數組的指針。　　ture表示:在所有線程對象變?yōu)橐淹ㄖ獱顟B(tài)之

27、前，該函數將不允許調用線程運行　　參數 -1 告訴系統，調用線程愿意永遠等待下去（無限時間量），直到該進程終止運行。　　三、運行結果　　程序運行結果如下：　　請選擇要進行的操作:

28、;　　1 （回車）　　1 （回車）　　請選擇要進行的操作:　　2 （回車）　　四、設計總結<

29、/p>　　本次操作系統課程設計完成的是讀者-寫者問題，通過學習對線程及其同步機制有了很的學習和掌握. 并認識到同步可以保證在一個時間內只有一個線程對某個資源有控制權。共享資源包括全局變量、公共數據成員或者句柄等。同步還可以使得有關聯交互作用的代碼按一定的順序執(zhí)行。同時也掌握了實現線程同步的對象有Critical_section（關鍵段），Event（事件），Mutex（互斥對象），Semaphores（信號量

30、）并對這些對象理解如下： 　　對于關鍵段對象：首先，定義一個關鍵段對象;然后，初始化該對象。初始化時把對象設置為NOT_SINGALED，表示允許線程使用資源：如果一段程序代碼需要對某個資源進行同步保護，則這是一段關鍵段代碼。在進入該關鍵段代碼前調用EnterCriticalSection函數，這樣，其他線程都不能執(zhí)行該段代碼，若它們試圖執(zhí)行就會被阻塞。完成關鍵段的執(zhí)行

31、之后，調用LeaveCriticalSection函數，其他的線程就可以繼續(xù)執(zhí)行該段代碼。如果該函數不被調用，則其他線程將無限期的等待。　　對于互斥對象首先，調用CreateMutex創(chuàng)建互斥對象；然后，調用等待函數，可以的話利用關鍵資源；最后，調用RealseMutex釋放互斥對象。互斥對象可以在進程間使用，但關鍵段對象只能用于同一進程的線程之間。

32、　對于等待函數：等待函數有：1.等待單個對象的(FOR SINGLE OBJECT): WaitForSingleObject,函數參數包括同步對象的句柄和等待時間等。如果等待時間不限制(Infinite)，則只有同步對象獲得信號才返回；如果等待時間為0，則在測試了同步對象的狀態(tài)之后馬上返回。2.等待多個對象的(FOR MULTIPLE OBJECTS) WaitForMultipleObjects,函數參數包括同步對象的句柄，等待時間

33、，是等待一個還是多個同步對象等等,如果等待時間不限制(Infinite)，則只有同步對象獲得信號才返回；如果等待時間為0，則在測試了同步對象的狀態(tài)之后馬上返回。　　操作系統設計使我對C++有了一個很好的復習和學習，對線程的創(chuàng)建及同步問題及其同步對象都有了很好的理解。并能初步進行簡單的程序編程。并對程序的調式過程，也使我更好了解到線程同步的具體運行過程，使我更好的理解程序。

34、　　學習語言是一個漫長的過程，我想只有在不斷的實踐練習中，才能更好的掌握編程的技巧，提高自己的編程能力，通過此次課設也讓我深深體會到自己還有很多東西需要學習，還有很多課程需要復習。總之，此次課程設計使我收益匪淺。　　五、源代碼　　#include <windows.h>

35、;　　#include<iostream.h>　　#include <conio.h> 　　#include "fstream.h" 　　int readcount=0; 　　int wr

36、itecount=0; 　　CRITICAL_SECTION RP_Write; 　　CRITICAL_SECTION cs_Write;　　CRITICAL_SECTION cs_Read;　　struct ThreadInfo

37、 　　{int Threadhao; 　　char ThreadClass; 　　double ThreadStartTime; 　　double ThreadRunTime; //線程讀寫持續(xù)時間&l

38、t;/p>　　};　　void ReaderFun(char* file);　　void R_ReaderThread(void *p);　　void R_WriterThread(void *p);

39、void WriterFun(char* file); 　　void W_ReaderThread(void *p);　　void W_WriterThread(void *p);　　int main()　　{

40、　　char select;　　while (true)　　{　　cout<<"***************讀者-寫者問題**************\n"<<endl;

41、;　　cout<<" 1:讀者優(yōu)先"<<endl;　　cout<<" 2:寫者優(yōu)先"<<endl;　　cout<<" 3:退出"<<e

42、ndl;　　cout<<"\n******************************************\n"<<endl;　　cout<<"請選擇要進行的操作:"<<endl;　　do</b

43、>　　{　　cin>>select;　　if(select!='1' && select!='2' && select!='3')　　c

44、out<<"你操作有誤，請重試！"<<endl;　　}while (select!='1' && select!='2' && select!='3');　　system("cls");&

45、lt;p>　　if (select=='3')　　return 0;　　else if (select=='1')　　ReaderFun("exia.txt");　　else

46、if(select=='2')　　WriterFun("exia.txt");　　cout<<"\n是否繼續(xù)? 1. 繼續(xù) 2.退出"<<endl;;　　do<

47、p>　　{　　cin>>select;　　if(select!='1' && select!='2' )　　cout<<"你操作有誤，請重試！"<<endl;<

48、/p>　　}while (select!='1' && select!='2');　　if(select=='2')　　return 0;　　system("cls"

49、;);　　}　　return 0;　　}　　void ReaderFun(char* file)

50、　{　　DWORD n_thread=0; //線程數初值為0　　DWORD thread_ID; 　　DWORD wait_for_all; 　　//臨界資源</p&

51、gt;　　HANDLE h_Mutex;　　//互斥對象(h_Mutex)確保線程擁有對單個資源的互斥訪問權　　h_Mutex=CreateMutex(NULL,FALSE,"mutex_for_readcount");　　/*創(chuàng)建互斥對象， &l

52、t;p>　　FALSE表示該互斥對象沒有被任何線程所擁有　　mutex_for_readcount是為內核對象賦予名字。　　*/　　HANDLE h_Thread[70];//線程對象數組，最大70　　ThreadInfo t

53、hread_info[70];　　readcount=0; 　　InitializeCriticalSection(&RP_Write); //初始化臨界區(qū)　　ifstream inFile;　　inFile.open(file);

54、 　　cout<<"讀者優(yōu)先:\n"<<endl;　　while (inFile)　　{　　//讀入每一個讀者、寫者的信息　　in

55、File>>thread_info[n_thread].Threadhao>>thread_info[n_thread].ThreadClass　　>>thread_info[n_thread].ThreadStartTime>>thread_info[n_thread].ThreadRunTime;　　i

56、f (-1 == inFile.get())　　break;　　n_thread++;//線程數加一　　}　　for (int i=0;i<(int)(n_thread);i++)</

57、p>　　{　　if (thread_info[i].ThreadClass=='r')　　//創(chuàng)建讀者線程　　h_Thread[i]=CreateThread(NULL,0,\

58、;　　(LPTHREAD_START_ROUTINE)(R_ReaderThread),\　　&thread_info[i],0,&thread_ID);　　/*　　0表示CreateThread就保留一個區(qū)域，并且將鏈接程序</p

59、>　　嵌入. EXE文件的/ STACK鏈接程序開關信息指明　　的存儲器容量分配給線程堆棧。　　(LPTHREAD_START_ROUTINE)(R_ReaderThread)表示新線程執(zhí)行的線程函數的地址　　&thread_info[i]表示在線程啟動執(zhí)行時將該參數傳遞給線程

60、函數。　　0表示讀者線程創(chuàng)建后可以立即進行調度　　&thread_ID表示CreateThread使用這個地址來存放系統分配　　給新讀者線程的I D　　*/　　els

61、e　　//創(chuàng)建寫者線程　　h_Thread[i]=CreateThread(NULL,0,\　　(LPTHREAD_START_ROUTINE)(R_WriterThread),\　　&thread_inf

62、o[i],0,&thread_ID);　　}　　wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);　　/*　　等

63、待函數可使線程自愿進入等待狀態(tài)，直到一個特定的內核對象變?yōu)橐淹ㄖ獱顟B(tài)為止　　n_thread表示線程數量。　　h_Thread是指向線程對象句柄的數組的指針。　　ture表示:在所有線程對象變?yōu)橐淹ㄖ獱顟B(tài)之前，該函數將不允許調用線程運行　　參數 -1 告訴系統，調用線程愿

64、意永遠等待下去（無限時間量），直到該進程終止運行。　　*/　　cout<<"所有的讀者和寫者線程完成操作."<<endl;　　}　　void R_Rea

65、derThread(void *p)　　{　　//互斥變量　　HANDLE h_Mutex;　　h_Mutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mut

66、ex_for_readcount");　　/*　　獲得它自己進程與現有互斥對象相關的句柄：　　*/　　DWORD wait_for_mutex; //等待互斥變量所有權</p&

67、gt;　　DWORD m_delay; //延遲時間　　DWORD m_ThreadRunTime; //讀文件持續(xù)時間　　int m_Threadhao; //線程序號　　m_Threadhao=((ThreadInfo *)(p))-&

68、gt;Threadhao;　　m_delay=(DWORD)(((ThreadInfo *)(p))->ThreadStartTime*100);　　m_ThreadRunTime=(DWORD)(((ThreadInfo *)(p))->ThreadRunTime*100);　　Sleep(m_de

69、lay); //延遲等待　　cout<<"讀者線程 "<<m_Threadhao<<" 發(fā)出讀請求."<<endl;　　wait_for_mutex=WaitForSingleObject(h_Mut

70、ex,-1); //等待互斥信號，保證對readcount的訪問、　　//修改互斥　　readcount++; 　　if (readcount==1)　　E

71、nterCriticalSection(&RP_Write);//禁止寫者進入 　　ReleaseMutex(h_Mutex);//釋放互斥對象，允許下個讀者繼續(xù)讀：　　cout<<"讀者線程 "<<m_Threadhao<<" 開始讀文件."<

72、<endl;　　Sleep(m_ThreadRunTime);　　cout<<"讀者線程 "<<m_Threadhao<<" 完成讀文件."<<endl;　　wait_for_mutex=WaitForSingleObj

73、ect(h_Mutex,-1); //等待互斥信號，保證對readcount的訪問、修改互斥　　readcount--; //讀者數目減少　　if (readcount==0)　　LeaveCriticalSection(&RP_W

74、rite); //如果所有讀者讀完，喚醒寫者　　ReleaseMutex(h_Mutex);//釋放互斥信號　　}　　void R_WriterThread(void *p)　　{

75、;　　DWORD m_delay; 　　DWORD m_ThreadRunTime; //讀文件持續(xù)時間　　int m_Threadhao; 　　//從參數中獲得信息　　m_Threadhao=(

76、(ThreadInfo *)(p))->Threadhao;　　m_delay=(DWORD)(((ThreadInfo *)(p))->ThreadStartTime*100);　　m_ThreadRunTime=(DWORD)(((ThreadInfo *)(p))->ThreadRunTime*100);&

77、lt;p>　　Sleep(m_delay); //延遲等待　　cout<<"寫者線程 "<<m_Threadhao<<" 發(fā)出寫請求."<<endl;　　EnterCriticalSection

78、(&RP_Write);//禁止下一位寫者進入　　cout<<"寫者線程 "<<m_Threadhao<<" 開始寫文件."<<endl;　　Sleep(m_ThreadRunTime);　　//退出

79、線程　　cout<<"寫者線程 "<<m_Threadhao<<" 完成寫文件."<<endl;　　LeaveCriticalSection(&RP_Write); //如果所有讀者讀完，喚醒寫者&

80、lt;p>　　}　　void WriterFun(char* file)　　{　　DWORD n_thread=0; //線程數目　　DWORD thread_ID;

81、 　　DWORD wait_for_all; 　　//互斥對象　　HANDLE h_Mutex1, h_Mutex2, h_Mutex3;　　h_Mutex1 = CreateMutex(NULL, FALSE, &q

82、uot;mutex_for_writecount");　　h_Mutex2 = CreateMutex(NULL, FALSE, "mutex_for_readcount");　　h_Mutex3 = CreateMutex(NULL, FALSE, "mutex_for_read");

83、;　　//線程對象數組　　HANDLE h_Thread[70];　　ThreadInfo thread_info[70];　　readcount=0; 　　InitializeCriticalSecti

84、on(&cs_Write); //初始化臨界區(qū)　　InitializeCriticalSection(&cs_Read);　　ifstream inFile;　　inFile.open(file); 　　cout&

85、lt;<"寫者優(yōu)先:\n"<<endl;　　while (inFile)　　{　　//讀入每一個讀者、寫者的信息　　inFile>>thread_info[n_thread].Thre

86、adhao>>thread_info[n_thread].ThreadClass　　>>thread_info[n_thread].ThreadStartTime>>thread_info[n_thread].ThreadRunTime;　　if(-1 == inFile.get())<p

87、>　　break;　　n_thread++;//線程數加一　　}　　for (int i=0;i<(int)(n_thread);i++)　　{&

88、lt;/p>　　if (thread_info[i].ThreadClass=='r')　　//創(chuàng)建讀者線程　　h_Thread[i]=CreateThread(NULL,0,\　　(LPTHREAD_START_ROUTINE)(

89、W_ReaderThread),\　　&thread_info[i],0,&thread_ID);　　else　　//創(chuàng)建寫者線程　　h_Thread[i]=CreateThrea

90、d(NULL,0,\　　(LPTHREAD_START_ROUTINE)(W_WriterThread),\　　&thread_info[i],0,&thread_ID);　　}　　//等待所有線程結束</p&g

91、t;　　wait_for_all=WaitForMultipleObjects(n_thread,h_Thread,TRUE,-1);　　cout<<"所有的讀者和寫者線程完成操作."<<endl;　　}　　v

92、oid W_WriterThread(void *p)　　{　　//互斥變量　　HANDLE h_Mutex1;　　h_Mutex1 = OpenMutex(MUTEX_ALL_ACCESS,FA

93、LSE,"mutex_for_writecount");　　DWORD wait_for_mutex; //等待互斥變量所有權　　DWORD m_delay; //延遲時間　　DWORD m_ThreadRunTime; //讀文件持時續(xù)間

94、;　　int m_Threadhao; 　　m_Threadhao=((ThreadInfo *)(p))->Threadhao;　　m_delay=(DWORD)(((ThreadInfo *)(p))->ThreadStartTime*100);　　m_T

95、hreadRunTime=(DWORD)(((ThreadInfo *)(p))->ThreadRunTime*100);　　Sleep(m_delay); 　　cout<<"寫者線程 "<<m_Threadhao<<&quo

96、t; 發(fā)出寫請求."<<endl;　　wait_for_mutex=WaitForSingleObject(h_Mutex1,-1); 　　writecount++;　　if (writecount==1)　　EnterCriticalSectio

97、n(&cs_Read);　　ReleaseMutex(h_Mutex1);　　EnterCriticalSection(&cs_Write);　　cout<<"寫者線程 "<<m_Threadhao<<" 開始寫文件."&

98、lt;<endl;　　Sleep(m_ThreadRunTime);　　cout<<"寫者線程 "<<m_Threadhao<<" 完成寫文件."<<endl;　　LeaveCriticalSection(&cs

99、_Write);　　wait_for_mutex=WaitForSingleObject(h_Mutex1,-1); 　　writecount--;　　if(writecount == 0)　　LeaveCriticalSection(&cs_Read);<

100、;/p>　　ReleaseMutex(h_Mutex1);　　}　　void W_ReaderThread(void *p)　　{　　HANDLE h_Mutex2,

101、h_Mutex3;　　h_Mutex2 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_readcount");　　h_Mutex3 = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"mutex_for_read");<

102、p>　　DWORD wait_for_mutex, wait_for_mutex1; //等待互斥變量所有權　　DWORD m_delay; 　　DWORD m_ThreadRunTime; //讀文件持續(xù)時間　　int m_Threadhao; &l

103、t;/p>　　m_Threadhao=((ThreadInfo *)(p))->Threadhao;　　m_delay=(DWORD)(((ThreadInfo *)(p))->ThreadStartTime*100);　　m_ThreadRunTime=(DWORD)(((ThreadInfo *)(p))-&g

104、t;ThreadRunTime*100);　　Sleep(m_delay);　　cout<<"讀者線程 "<<m_Threadhao<<" 發(fā)出讀請求."<<endl;　　wait_for_mutex1=WaitForSing

105、leObject(h_Mutex3,-1);　　EnterCriticalSection(&cs_Read);　　LeaveCriticalSection(&cs_Read);　　ReleaseMutex(h_Mutex3);　　wait_for_mute

106、x=WaitForSingleObject(h_Mutex2,-1); 　　readcount++;　　if (readcount == 1)　　EnterCriticalSection(&cs_Write);　　ReleaseMutex(h_Mutex2);&l

107、t;/p>　　cout<<"讀者線程 "<<m_Threadhao<<" 開始讀文件."<<endl;　　Sleep(m_ThreadRunTime);　　cout<<"讀者線程 "<<m_Thr

108、eadhao<<" 完成讀文件."<<endl;　　wait_for_mutex=WaitForSingleObject(h_Mutex2,-1);　　readcount--;　　if (readcount == 0)　　Lea

眾賞文庫> 全部分類> 畢業(yè)設計

溫馨提示

1. 本站所有資源如無特殊說明，都需要本地電腦安裝OFFICE2007和PDF閱讀器。圖紙軟件為CAD,CAXA,PROE,UG,SolidWorks等.壓縮文件請下載最新的WinRAR軟件解壓。
2. 本站的文檔不包含任何第三方提供的附件圖紙等，如果需要附件，請聯系上傳者。文件的所有權益歸上傳用戶所有。
3. 本站RAR壓縮包中若帶圖紙，網頁內容里面會有圖紙預覽，若沒有圖紙預覽就沒有圖紙。
4. 未經權益所有人同意不得將文件中的內容挪作商業(yè)或盈利用途。
5. 眾賞文庫僅提供信息存儲空間，僅對用戶上傳內容的表現方式做保護處理，對用戶上傳分享的文檔內容本身不做任何修改或編輯，并不能對任何下載內容負責。
6. 下載文件中如有侵權或不適當內容，請與我們聯系，我們立即糾正。
7. 本站不保證下載資源的準確性、安全性和完整性, 同時也不承擔用戶因使用這些下載資源對自己和他人造成任何形式的傷害或損失。

操作系統課程設計---讀者-寫者問題實現

文檔簡介

溫馨提示

最新文檔

評論

操作系統課程設計---讀者-寫者問題實現

文檔簡介

溫馨提示

最新文檔

評論

免費下載