操作系統(tǒng)課程設計--銀行家算法

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

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

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

文檔簡介

1、　　Dijkstra的銀行家算法是最有代表性的避免死鎖的算法，該算法由于能用于銀行系統(tǒng)現(xiàn)金貸款的發(fā)放而得名。銀行家算法是在確保當前系統(tǒng)安全的前提下推進的。對進程請求先進行安全性檢查，來決定資源分配與否，從而確保系統(tǒng)的安全，有效的避免了死鎖的發(fā)生。　　該論文在理解和分析了銀行家算法的核心思想以及狀態(tài)的本質涵義的前提下，對算法的實現(xiàn)在總體上進行了設計，包括在對算法分模塊設計，并對各

2、個模塊的算法思想通過流程圖表示，分塊編寫代碼，并進行測試，最后進行程序的測試，在設計思路上嚴格按照軟件工程的思想執(zhí)行，確保了設計和實現(xiàn)的可行，可信。代碼實現(xiàn)采用C語言。 　　關鍵詞：銀行家算法；死鎖；避免死鎖；安全性序列　　abstract　　The banker Dij

3、kstra algorithm is the most representative of avoid deadlock algorithm, this algorithm can be used in the banking system due to cash the release of the loan and its name. Bankers algorithm is to ensure the safety in the

4、current system under the premise of the advance. To process request to safety inspection to determine resource allocation or not, so as to ensure the security of the system, effective avoid deadlocks occur.&l

5、t;p>　　The paper in the understanding and analysis of the banker algorithm is the core idea of the state and the essence of the meaning on the premise of the realization of the algorithm in the overall design, includin

6、g in the algorithm points module design, and each module algorithm thought through the flow chart, said block coding, and testing, the program testing, in the design idea in strict accordance with the concept of software

7、 engineering implementation, to ensure that the design and implementa　　Keywords: bankers algorithm; Deadlock; Avoid deadlock; Safety sequence　　前言:20世紀末，隨著計算機科學的發(fā)展，C語言的應用越來越廣泛，很多程

8、序都需要使用C語言來編寫。C語言使用方便快捷，它已經(jīng)成為計算機編程中不可缺少的一部分，而且它也被用于各個方面。例如：政府部門，銀行，學校等等。　　銀行家算法是判斷系統(tǒng)是否安全，并且允許其它進程來申請這里的資源，任何一個進程來申請資源時，必須先登記該進程對資源的申請要求然后由系統(tǒng)檢查當前資源的狀況，并用銀行家算法和安全性算法來檢查是否允許分配資源給進程。通過課程設計，加深我們對利用銀行家算法避免

9、死鎖的理解。在設計中主要的難點是用語言編寫銀行家算法和安全性算法，使系統(tǒng)資源分配能安全進行，避免系統(tǒng)死鎖。　　緒論　　1 進程并發(fā)控制的必要性　　控制工作流程，管理資源，為用戶服務，是操作系統(tǒng)的主要功能。在資源管理中，操作系統(tǒng)的任務是使各種系統(tǒng)資源得到充分合理的應用，解決用戶

10、作業(yè)因為資源而產(chǎn)生的矛盾，并合理地讓用戶在合適的時間內得到其應有的服務。　　現(xiàn)代操作系統(tǒng)引入了多道程序設計技術，允許多個進程同時駐留內存并發(fā)執(zhí)行。若干個進程將不可避免地會競爭系統(tǒng)資源，如果操作系統(tǒng)不能協(xié)調多個進程對系統(tǒng)資源的競爭和共享，將會導致執(zhí)行結果異常，系統(tǒng)不穩(wěn)定、失效等多種問題，因此操作系統(tǒng)提供了多種機制實現(xiàn)對進程的并發(fā)控制。

11、2進程死鎖的定義　　操作系統(tǒng)利用了包括軟件方法、硬件方法、信號量方法、管程方法以及消息傳遞方法等機制實現(xiàn)了對若干進程的同步與互斥的控制，但是要確保進程之間能夠正常通信、合理分配系統(tǒng)資源、提高系統(tǒng)的運行效率還需要解決進程的死鎖問題。　　死鎖可以描述為，當多個進程在執(zhí)行過程中，因為競爭資源或執(zhí)行時推進的順序不當而造成的一種相互阻塞的現(xiàn)象，

12、若無外力作用，它們都將無法推進下去。　　3產(chǎn)生死鎖的原因　　一、競爭資源引起進程死鎖　　當系統(tǒng)中供多個進程共享的資源如打印機、公用隊列的等，其數(shù)目不足以滿足諸進程的需要時，會引起諸進程對資源的競爭而產(chǎn)生死鎖。　　二、進程推進順序不當引

13、起死鎖　　由于進程在運行中具有異步性特征，這可能使P1和P2兩個進程按下述兩種順序向前推進。 　　4死鎖產(chǎn)生的必要條件　　雖然進程在運行過程中，可能發(fā)生死鎖，但死鎖的發(fā)生也必須具備一定的條件，死鎖的發(fā)生必須具備以下四個必要條件。 　?。?）互斥條件　?。?）占有且等待

14、（3）非剝奪　?。?）循環(huán)等待如圖2-1.　　互斥，占有且等待，非剝奪這三個條件是死鎖產(chǎn)生的必要條件，但不是充分條件?；コ鈼l件是臨界資源固有的屬性，保證進程胡此訪問臨界資源是必要的，不能因為互斥會導致死鎖而禁止互斥。循環(huán)等待是前3個條件可能產(chǎn)生的結果，只有存在互斥，占有且等待與非剝奪三個條件時，才可能出現(xiàn)循環(huán)等待。只要系統(tǒng)出現(xiàn)了循環(huán)等待，則一定出現(xiàn)死鎖。

15、　　5 解決死鎖的方法　　解決死鎖的方法可以按解決死鎖的時機分為四類：　　（1) 預防死鎖。　?。?) 避免死鎖。&

16、lt;b>　?。?)檢測死鎖。 　　（4)解除死鎖。 　　需求分析　　1 問題描述　　運用銀行家算法，避免死鎖的發(fā)生。在確保當前系統(tǒng)

17、安全的前提下推進的。對進程請求先進行安全性檢查，來決定資源分配與否，從而確保系統(tǒng)的安全，有效的避免了死鎖的發(fā)生。　　問題的關鍵在于安全性算法，即找安全性序列。　　2功能需求　　1.添加進程的可用資源，最大資源，已分配資源；　　2.判斷

18、系統(tǒng)是否安全；　　3.申請資源；　　4.申請資源后如何分配；　　5.進行安全檢查。　　3數(shù)據(jù)需求　　主要數(shù)據(jù)包括：可

19、用資源，最大資源，已分配資源，申請資源數(shù)　　4基本要求　　（1）從鍵盤輸入當前系統(tǒng)的資源信息，包括當前可用資源，每個進程對各類資源的最大需求量，每個進程當前已分配的各個資源量和每個進程尚需要的各個資源量，輸出結果顯示在DOS界面上；　?。?）輸入進程請求，按照設計好的安全性算

20、法進行檢查，得到結果并輸出整個執(zhí)行過程的相關信息和最終結果（主要包括資源分配表和安全序列）　　（3）要求要有各種異常的處理，程序的可控制性和可連續(xù)性執(zhí)行。包括對進程的存在有無檢查，請求向量的不合法檢查，試分配失敗后的數(shù)據(jù)恢復和重新接受進程請求等。　　5數(shù)據(jù)流模型<b&g

21、t;　　概要設計　　1算法思路：　　先對用戶提出的請求進行合法性檢查，即檢查請求是否大于需要的，是否大于可利用的。若請求合法，則進行預分配，對分配后的狀態(tài)調用安全性算法進行檢查。若安全，則分配；若不安全，則拒絕申請，恢復到原來的狀態(tài)，拒絕申請。<b&

22、gt;　　2總體設計　　總體功能模塊圖如下　　3模塊的劃分　　由于該算法規(guī)模較小，所以選用結構化的設計方法，將該系統(tǒng)劃為五塊，分別是：　　(1)主模塊，處在整個系統(tǒng)的最高層，負

23、責組織調用其他模塊。　?。?）初始化模塊，負責從鍵盤讀入系統(tǒng)資源和進程狀態(tài)，并將系統(tǒng)初識資源分配狀態(tài)打印。　?。?）試分配模塊，負責處理進程請求，和相應的數(shù)據(jù)結構的修改，已經(jīng)特殊情況的處理。　?。?）安全性檢查，負責試分配后的安全性檢查，以及系統(tǒng)不安全時的資源恢復。<

24、;b>　　4模塊調用關系　　各模塊之間的調用如下圖示：　　5 流程圖　　1：主函數(shù)流程圖：　　2：初始化流程

25、　　3：安全性檢測流程圖　　4:銀行家算法流程圖　　詳細設計　　1.算法的數(shù)據(jù)結構　　可利用資源向量Available　　是個含有m個元

26、素的數(shù)組，其中的每一個元素代表一類可利用的資源數(shù)目。如果Available[j]=K，則表示系統(tǒng)中現(xiàn)有Rj類資源K個?！　?lt;/p>　　最大需求矩陣Max　　　　這是一個n×m的矩陣，它定義了系統(tǒng)中n個進程中的每一個進程對m類資源的最大需求。如果Max[i,j]=K，則表示進程i需要Rj類資源的最大數(shù)目為K?！　?lt;/p>

27、　　分配矩陣Allocation　　　　這也是一個n×m的矩陣，它定義了系統(tǒng)中每一類資源當前已分配給每一進程的資源數(shù)。如果Allocation[i,j]=K，則表示進程i當前已分得Rj類資源的數(shù)目為K?！　?lt;/p>　　需求矩陣Need?！　?lt;/p>　　這也是一個n×m的矩陣，用以表示每一個進程尚需的各類資源

28、數(shù)。如果Need[i,j]=K，則表示進程i還需要Rj類資源K個，方能完成其任務。　　2.算法的實現(xiàn)　　1）初始化　　即是初始化Max，Allocation，Available，Need這四個數(shù)組。其中Max，Allocation，Ava

29、ilable這三個數(shù)組在程序開始前是已知的，Need數(shù)組是根據(jù)Max和Allocation計算出來的。　　2）銀行家算法　　在避免死鎖的方法中，所施加的限制條件較弱，有可能獲得令人滿意的系統(tǒng)性能。在該方法中把系統(tǒng)的狀態(tài)分為安全狀態(tài)和不安全狀態(tài)，只要能使系統(tǒng)始終都處于安全狀態(tài)，便可以避免發(fā)生死鎖。

30、　　如果REQUEST[i]<= NEED[REQUEST][i]，則轉(2)；否則，出錯?！　?lt;/p>　　(2)如果REQUEST[i]<= Avalable[REQUEST][i]，則轉(3)；否則，出錯?！　?lt;/p>　　(3)系統(tǒng)試探分配資源，修改相關數(shù)據(jù)：　　　　Avalable[i]=

31、 Avalable[i]-Request[i];　　　Allocation[REQUEST][i]= Allocation[REQUEST][i]+Request[i];　　Need[REQUEST][i]= Need[REQUEST][i]-Request[i];　　（4)系統(tǒng)利用安全性算法，檢查此次資源分配以

32、后，系統(tǒng)是否處于安全狀態(tài)。若安全，才將資源分配給是進程Pi,完成此次分配；否則，試探分配是小，回復原來的資源分配狀態(tài)，讓進程Pi等待。　　3）安全性檢查算法　　(1)設置兩個工作向量：　　Finish[FACT_PROGRESS]：若Finish[n]=true,則表示該進程

33、已經(jīng)申請到了資源得到執(zhí)行。當該進程執(zhí)行完畢后，釋放資源。FACT_PROGRESS代表實際進程集合的數(shù)量?！inish數(shù)組初始化時，全部元素置為false。　　Work[FACT_SOURCE]：初始化為Available，表示系統(tǒng)可提供給進程繼續(xù)運行的資源集合。FACT_SOURCE是一個全局變量，表示實際的資源種類。　　從進程集合中找到一個滿足下述

34、條件的進程：　　Finish[i]==false并且Need[i][]<=Work[];如找到，則執(zhí)行(3)；否則，執(zhí)行(4)。　　這是系統(tǒng)找到了一個滿足條件的進程，并讓該進程得資源，可順利執(zhí)行，直至完成，從而釋放所有的資源，執(zhí)行以下操作：　　Work[]= Work[]+Allocation[i][];&

35、lt;/p>　　Need[i][]=0;　　Available[i][]=Available[i][]+Allocation[i][];　　Allocation[i][]=0;　　Finish=true;　　　　然后返回（2）找到符合條件的進程

36、并執(zhí)行相關操作，直到?jīng)]有找到符合條件的進程為止?！?lt;/p>　　如所有的進程Finish[]= true，則申請的資源分配可以使所有的進程都順利執(zhí)行，表示系統(tǒng)處于安全狀態(tài)；若Finish[]數(shù)組不全為true，則表示申請資源的進程所申請的資源分配不能是系統(tǒng)中所有的進程都順利得到資源并執(zhí)行，系統(tǒng)不安全狀態(tài)　　源代碼</p&

37、gt;　　//銀行家算法　　#include<stdio.h>　　#include<stdlib.h>　　#include<string.h>　　#define M 3 //

38、系統(tǒng)資源的種類　　#define N 10 // 進程上限　　#define D12 %5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d%5d //輸入輸出格式定義　　typedef struct my_process　　{</b

39、>　　int num; //進程標號　　int Max[M];// 表示某個進程對某類資源的最大需求　　int Allocation[M];// 表示某個進程已分配到某類資源的個數(shù)　　int Need[M];// 表示某個進程尚需要

40、某類資源的個數(shù)　　struct my_process* next;　　}process;　　void Insret_Tail(process **head,process node) //尾插法建立進程鏈表

41、{　　process* p=(process*)malloc(sizeof(process));　　process* last=NULL;　　memcpy(p,&node,sizeof(process)); //動態(tài)創(chuàng)建進程結點　　p-

42、>next=NULL;　　if(NULL==*head)　　{　　*head=p;　　}　　else

43、 //找表尾　　{　　last=*head;　　while(last->next!=NULL)　　{　　last=last->next;<

44、;/p>　　}　　last->next=p;//插入鏈尾　　}　　}　　void Init_process(process *

45、*head,int m,int* count)//初始化系統(tǒng)資源　　{　　int i,j=0;　　process node;　　printf("請初始化一組進程,進程編號從0開始，輸入-1 結束輸入:\n");

46、　　do　　{　　node.num=j++;　　printf("請輸入第 %d個進程信息 :\n",node.num);　　print

47、f("最大需求矩陣: ");　　scanf("%d",&node.Max[0]);　　if(node.Max[0]!=-1) //輸入-1 結束輸入　　{　　fo

48、r(i=1;i<m;i++)　　{　　scanf("%d",&node.Max[i]);　　}　　printf("分配矩陣: ");</

49、p>　　for(i=0;i<m;i++)　　{　　scanf("%d",&node.Allocation[i]);　　}　　print

50、f("需求矩陣: ");　　for(i=0;i<m;i++)　　{　　scanf("%d",&node.Need[i]);　　}</p&

51、gt;　　Insret_Tail(head,node);//插入鏈尾　　(*count)++;//進程數(shù)加1　　}　　else　　{&

52、lt;/b>　　break;　　}　　}　　while(1);<b

53、>　　}　　void Print(process *head,int *avail,int m)//打印初識系統(tǒng)資源　　{　　process* p=NULL;　　int i,j;<

54、/b>　　char ch;　　p=head;　　if(NULL==p)　　{　　printf(&

55、quot;當前無進程 !\n"); 　　exit(0);　　}　　else　　{</p&g

57、lt;b>　　{　　ch='A';　　for(j=0;j<m;j++)　　{　　printf("%4c",ch++);</

58、p>　　}　　printf("\t");　　}　　puts("");　　while(p!=

59、NULL)　　{　　printf("%8.2d",p->num);　　for(j=0;j<m;j++)　　{　　print

60、f("%4d",p->Max[j]);　　}　　printf("\t");　　for(j=0;j<m;j++)　　{&l

61、t;p>　　printf("%4d",p->Allocation[j]);　　}　　printf("\t");　　for(j=0;j<m;j++)　　{<

62、;/b>　　printf("%4d",p->Need[j]);　　}　　printf("\t");　　for(j=0;j<m;j++)

63、　　{　　printf("%4d",avail[j]);　　}　　printf("\n");　　p=p->next;<p

64、>　　}　　puts("");　　}　　}　　process* Location(proces

65、s* head,int pro_num)//進程定位函數(shù)，找到當前請求進程在進程鏈表中的位置，以便后面對其操作　　{　　process *p=NULL;　　p=head;　　if(NULL==p

66、)　　{　　printf("error !\n");//異常，當前鏈表為空　　return p;　　}&l

67、t;p>　　else　　{　　while(p!=NULL)　　{　　if(p->num==pro_num)

68、;　　{　　break;　　}　　else　　{<p

69、>　　p=p->next;　　}　　}　　if(NULL==p)//無此進程，輸入錯誤　　{

70、　　printf("無此進程 !\n");　　return p;　　}　　else 　　{</

71、p>　　return p;　　}　　}　　}　　process* Attempt_Alloc

72、ation(process* head,int *request,int *avail,int m)　　{//試分配　　int num,i;　　process* p=NULL;　　printf("請輸入進程編號: \n&q

73、uot;);　　scanf("%d",&num);　　p=Location(head,num);　　if(p==NULL)　　{　　printf("無此進

74、程!\n");　　return p;　　}　　printf("請輸入該進程的請求向量: \n");　　for(i=0;i<m;i++)&

75、lt;p>　　{　　scanf("%d",&request[i]);　　}　　for(i=0;i<m;i++)//請求的合法性檢驗

76、{　　if(request[i]<=p->Need[i])　　{　　;　　}<

77、b>　　else　　{　　printf("該請求系統(tǒng)不能滿足 !\n");　　return NULL;　　}

78、　　}　　for(i=0;i<m;i++)　　{　　if(request[i]<=avail[i])　　{

79、;　　;　　}　　else　　{　　printf("該請求系統(tǒng)不能滿足 !\n");</p&

80、gt;　　return NULL;　　}　　}　　for(i=0;i<m;i++) //試分配，修改相關數(shù)據(jù)結構

81、;　　{　　avail[i]=avail[i] - request[i];　　p->Allocation[i]=p->Allocation[i] + request[i];　　p->Need[i]=p->Need[i] - request[i];

82、　　}　　return p;　　}　　process* Reasonable(process* head,int*finish,int*work,int m,int n)//找當

83、前可執(zhí)行的進程　　{　　int i=0,j=0,count=0;　　process* p=NULL;　　while(1)　　{<

84、/b>　　if(finish[i]!=-1) //表示該進程未執(zhí)行安全性檢查　　{　　p=Location(head,finish[i]);//定位該進程　　if(p!=NULL)

85、　　{　　for(j=0;j<m;j++)　　{　　if(p->Need[j]>work[j])　　{<p&g

86、t;　　break;　　}　　else　　{　　continue;</p&g

87、t;　　}　　}　　if(j==m)　　{　　return p;</b&g

88、t;　　}　　else　　{　　i++; //當前進程檢查沒有通過，則進行下一個進程的檢查

89、　}　　}　　}　　else　　{　　i++; //當

90、前進程已經(jīng)檢查過，則進行下一個進程的檢查　　}　　if(i==n)　　{　　return NULL; //遍歷所有進程都未找到，則跳出返回NULL</

91、p>　　}　　}　　}　　void Alter_Data(process* p,int* work,int* finish,int record[][M],int m)

92、//修改相關數(shù)據(jù)結構　　{　　int i;　　for(i=0;i<m;i++)　　{　　record[p-&g

93、t;num][i]=work[i];　　work[i]=work[i]+p->Allocation[i];　　}　　finish[p->num]=-1; //表示該進程已通過安全性檢查　　}</

94、b>　　int Safety_Algorithm(process* head,int *avail,int *safety,int Record[][M],int m,int n)//安全性算法　　{　　int *work=NULL;<p&

95、gt;　　int *finish=NULL;　　process *p=NULL;　　process *pro=NULL;　　int i,count=0;　　work=(int*)malloc(m*sizeof(int));//當前系統(tǒng)可供給進程的各個資源數(shù)目</

96、p>　　finish=(int*)malloc(n*sizeof(int));//標志數(shù)組　　//safety=(int*)malloc(n*sizeof(int));　　p=head;　　for(i=0;i<m;i++)</p&g

97、t;　　{　　work[i]=avail[i];　　}　　i=0;　　while(p!=NULL)<p&

98、gt;　　{　　finish[i]=p->num;　　p=p->next;　　i++;　　}<b&

99、gt;　　i=0;　　while(count<n)　　{　　pro=Reasonable(head,finish,work,m,n);　　if(pro!=NULL)//Need[i,j]<

100、=work[j],即當前系統(tǒng)可以滿足該進程　　{　　Alter_Data(pro,work,finish,Record,m);　　count++;　　safety[i]=pro->num;

101、 //　　i++;　　}　　else　　{　　printf("當前

102、系統(tǒng)處于不安全狀態(tài) !\n");　　//remark=1;　　break;　　}　　}　　if(coun

103、t==n)　　{　　printf("當前系統(tǒng)處于安全狀態(tài),存在一個安全序列 :\n");　　for(i=0;i<n;i++)　　{

104、;　　printf("%d,",safety[i]); //打印安全序列　　}　　puts("");　　}

105、free(finish);　　free(work);　　finish=NULL;　　work=NULL;　　if(count==n)　　{　　retu

106、rn 1; //找到安全序列則返回1　　}　　else　　{　　return 0;//未找到安全序列則返回0&

107、lt;b>　　}　　}　　void Return_Source(process* p,int *request,int *avail,int m) //若試分配失敗，則恢復試分配前的資源狀態(tài)　　{</p&

108、gt;　　int i;　　{　　for(i=0;i<m;i++)　　{　　p->Allocation[i]-=request

109、[i];　　p->Need[i]+=request[i];　　avail[i]+=request[i];　　}　　}　　}<

110、/b>　　void Print_After_Safety(process *head,int *safety,int work[][M],int m,int n) //打印試分配后的系統(tǒng)資源狀態(tài)　　{　　process* p=NULL;<

111、p>　　int i,j;　　char ch;　　p=head;　　if(NULL==p)　　{

112、　　exit(0);　　}　　else　　{　　printf("| Process |

113、 Work | | Need | |Allocation| |Work+Allocation| | Finish |\n\n");　　printf("\t");　　for(i=0;i<4;i++)　　{</b

114、>　　ch='A';　　for(j=0;j<m;j++)　　{　　printf("%4c",ch++);&

115、lt;b>　　}　　printf("\t");　　}　　puts("");　　for(i=0;i<n;i++)</p&

116、gt;　　{　　p=head;　　while(p!=NULL)　　{　　if(p->num==safety[i])</p&

117、gt;　　{printf("%8.2d",p->num);　　for(j=0;j<m;j++)　　{　　printf("%4d",work[p->num][j]);<

118、;p>　　}　　printf("\t");　　for(j=0;j<m;j++)　　{　　printf("%4d",p->Need[j]);

119、　　}　　printf("\t");　　for(j=0;j<m;j++)　　{　　printf("%4d",

120、p->Allocation[j]);　　}　　printf("\t");　　for(j=0;j<m;j++)　　{　　pr

121、intf("%4d",work[p->num][j]+p->Allocation[j]);　　}　　printf("\n");　　break;&

122、lt;b>　　}　　else　　{　　p=p->next;　　}

123、　}　　puts("");　　}　　}　　}<p&

124、gt;　　void main()　　{　　int i,flag=0,count=0;　　char ch;　　int *p=NULL;//進程鏈頭指針數(shù)組

125、;　　int Available[M]={0};// 其中每一個數(shù)組元素表示當前某類資源的可用數(shù)目，初始化為系統(tǒng)所提供的資源的最大數(shù)目　　int Request[M]={0};　　int Record_work[N][M]={0};　　int Safety[N]={0}; //存儲安全序列，以便后面排序

126、　　process *head=NULL;　　process *pro=NULL;　　p=&count;　　printf("請初始化當前可用資源 !\n");

127、　for(i=0;i<M;i++)　　{　　scanf("%d",&Available[i]);　　}　　Init_process(&head,M,p);

128、//初識化系統(tǒng)資源　　Print(head,Available,M); //打印初始化資源狀況　　do　　{　　flag=Safety_Algorithm(head,Available,

129、Safety,Record_work,M,count); //安全性檢驗　　if(1==flag)　　{　　printf("當前系統(tǒng)是安全的，可進行試探分配 !\n");　　do

130、;　　{　　pro=Attempt_Allocation(head,Request,Available,M); //通過則試分配　　if(NULL!=pro)　　{

131、　　printf("試分配成功，當前系統(tǒng)資源分配如下表 !\n");　　Print(head,Available,M);　　break;　　}　　else

132、// 否則，退到上一級　　{　　printf("當前請求系統(tǒng)不能滿足 ! 您可以選擇重新輸入請求向量(Y/y)，或者退出(N/n)\n\n");　　printf("您是否要繼續(xù)操作 (Y/N):\n");

133、　　getchar();　　scanf("%c",&ch);　　if(ch=='N'|| ch=='n')　　{　　exit(0);&

134、lt;/b>　　}　　}　　}while(ch=='Y'||ch=='y');　　}<p&

135、gt;　　else //未通過安全性算法　　{　　printf("當前系統(tǒng)不安全，不能響應任何進程的請求 !\n");　　exit(0);　　}

136、　　flag=Safety_Algorithm(head,Available,Safety,Record_work,M,count);　　if(1==flag)　　{　　printf("分配成功！當前資源

137、分配狀態(tài)如下表 :\n");　　Print_After_Safety(head,Safety,Record_work,M,count);　　printf("您是否還要繼續(xù)操作 (Y(y)/N(y)\n)");　　getchar();　　sca

138、nf("%c",&ch);　　}　　else　　{　　printf("當前系統(tǒng)處于不安全狀態(tài),本次嘗試分配作廢，恢復原來

139、的資源分配狀態(tài) ! :\n");　　Return_Source(pro,Request,Available,M);　　Print(head,Available,M);　　printf("您是否還要繼續(xù)操作 (Y(y)/N(y)\n)");

140、getchar();　　scanf("%c",&ch);　　}　　}while(ch=='Y'|| ch=='y');　　printf("您已經(jīng)正常退出!\n\n&

141、quot;);　　}　　程序分析測試　　函數(shù)的書寫分模塊進行，每完成一個模塊進行調試、測試直到該函數(shù)運行無誤。　　1初始化系統(tǒng)資源模塊Init_process(process **head,i

142、nt m,int* count)的測試　　按提示輸入，以-1結束整個初始化過程，并打印結果。　　2 試分配模塊Attempt_Allocation的測試　　試分配模塊，主要是在系統(tǒng)進過第一次安全檢查后，對系統(tǒng)資源的一次嘗試性分配，試分配完成后，相關的數(shù)據(jù)結構被修改。　　3

143、安全模塊Safety_Algorithm的調試　　試分配前的安全算法，結果如果輸出一個安全性序列，并且經(jīng)過人工檢查該安全性序列，確實有效，則該模塊正確；如果系統(tǒng)不安全，打印出相關信息，返回上一層。效果如下圖示：　　（2）試分配后的安全算法，結果如果輸出一個安全性序列，并且經(jīng)過人工檢查該安全性序列，確實有效，則該模塊正確；否則，之前的試分配作廢，恢復試分配

144、前的資源狀態(tài)。　　設計體會　　經(jīng)過幾天的自己動手練習，對操作系統(tǒng)的掌握又進了一步，收獲了很多課堂上和書上未出現(xiàn)過的或老師未講到的一些知識。在完成實驗的過程中，進行了反復的修改和調試，這次實驗，讓我基本上明白了銀行家算法的基本原理，加深了對課堂上知識的理解，也懂得了如何讓銀行家算法實現(xiàn)，但編程功底的原因使程序很是繁瑣。

145、　　這次的設計數(shù)據(jù)是通過一道實際的題目來體現(xiàn)銀行家算法避免死鎖的問題，先用銀行家算法給其中一個進程分配資源，看它所請求的資源是否大于它的需求量，才和系統(tǒng)所能給的資源相比較.讓進程形成一個安全隊列,看系統(tǒng)是否安全.再利用安全性算法檢查此時系統(tǒng)是否安全。　　要做一個課程設計，如果知識面只是停留在書本上，是不可能把課程設計完全地做好。用VC++6.0編程，感覺

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

溫馨提示

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

操作系統(tǒng)課程設計--銀行家算法

文檔簡介

溫馨提示

最新文檔

評論

操作系統(tǒng)課程設計--銀行家算法

文檔簡介

溫馨提示

最新文檔

評論

免費下載