銀行家演算法並發程度

『壹』 操作系統銀行家演算法實驗，求高手指導！！！急！！！

很難嗎·？

『貳』 進程同步及銀行家演算法的模擬實現 有會的大俠們幫幫忙吧 這個要求實在是太多 不太懂 答的好的追100

銀行家演算法=-- -

1. 安全狀態: 在某時刻系統中所有進程可以排列一個安全序列:,剛稱此時,系統是安全的.
所謂安全序列是指對於P2,都有它所需要剩餘資源數量不大於系統掌握的剩餘的空間資源與所有Pi(j<i)所佔的資源之和.
2.不安全狀態可能產生死鎖.
目前狀態 最大需求 尚需
P1 3 9 6
P2 5 10 5
P3 2 4 2

在每一次進程中申請的資源,判定一下,若實際分配的話,之後系統是否安全.
3.銀行家演算法的思路:
1),進程一開始向系統提出最大需求量.
2),進程每次提出新的需求(分期貸款)都統計是否超出它事先提出的最大需求量.
3),若正常,則判斷該進程所需剩餘剩餘量(包括本次申請)是否超出系統所掌握的
剩餘資源量,若不超出,則分配,否則等待.
4.銀行家演算法的數據結構.
1),系統剩餘資源量A[n],其中A[n]表示第I類資源剩餘量.
2),各進程最大需求量,B[m][n],其中B[j][i]表示進程j對i
類資源最大需求.
3),已分配資源量C[m][n],其中C[j][i]表示系統j程已得到的第i資源的數量.
4),剩餘需求量.D[m][n],其中D[j][i]對第i資源尚需的數目.
5.銀行家演算法流程:當某時刻,某進程時,提出新的資源申請,系統作以下操作:
1),判定E[n]是否大於D[j][n],若大於,表示出錯.
2),判定E[n]是否大於系統剩餘量A[n],若大於,則該進程等待.
3),若以上兩步沒有問題,嘗試分配,即各變數作調整.
4),按照安全性推測演算法,判斷,分配過後,系統是否安全,若安全,則實際分配,否則,撤消分配,讓進程等待.
6."安全性檢測"演算法
1),先定義兩個變數,用來表示推算過程的數據.
F[n]=A[n],表示推算過程中,系統中剩餘資源量的變化.
J[n]=False表示推算過程中各進程是否假設"已完成"
2),流程:
在"剩餘"的進程中(在推算)過程中,一些進程假設已完成,查找D[j][n]<=F[n]的進程,找到後令J[j]=True
(假設該進程完成),F[n]+D[j][n](該進程所佔資源釋放),如此循環執行.
若最後,所有的F[n]=True(在推算過程中,所有進程均可以完成),則表示(分配過後)系統是安全的,否則系統是不安全的.

#include "malloc.h"
#include "stdio.h"
#define alloclen sizeof(struct allocation)
#define maxlen sizeof(struct max)
#define avalen sizeof(struct available)
#define needlen sizeof(struct need)
#define finilen sizeof(struct finish)
#define pathlen sizeof(struct path)
struct allocation
{
int value;
struct allocation *next;
};
struct max
{
int value;
struct max *next;
};
struct available
{
int value;
struct available *next;
};
struct need
{
int value;
struct need *next;
};
struct path
{
int value;
struct path *next;
};
struct finish
{
int stat;
struct finish *next;
};
int main()
{
int row,colum,status=0,i,j,t,temp,processtest;
struct allocation *allochead,*alloc1,*alloc2,*alloctemp;
struct max *maxhead,*maxium1,*maxium2,*maxtemp;
struct available *avahead,*available1,*available2,*availabletemp,*workhead,*work1,*work2,*worktemp,*worktemp1;
struct need *needhead,*need1,*need2,*needtemp;
struct finish *finihead,*finish1,*finish2,*finishtemp;
struct path *pathhead,*path1,*path2,*pathtemp;
char c;
printf("\nPlease enter the type of sources the system has:\n");
scanf("%d",&colum);
printf("Please enter the number of processes now in the memory:\n");
scanf("%d",&row);
printf("Please enter the allocation array:\n");
for(i=0;i<row;i++)
{
printf("The allocation for process p%d:\n",i);
for (j=0;j<colum;j++)
{
printf("The type %c system resource allocated:\n",'A'+j);
if(status==0)
{
allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);
alloc1->next=alloc2->next=NULL;
scanf("%d",&allochead->value);
status++;
}
else
{
alloc2=(struct allocation *)malloc(alloclen);
scanf("%d,%d",&alloc2->value);
if(status==1)
{
allochead->next=alloc2;
status++;
}
alloc1->next=alloc2;
alloc1=alloc2;
}
}
}
alloc2->next=NULL;
status=0;
printf("Please enter the max array:\n");
for(i=0;i<row;i++)
{
printf("The max needed from process p%d:\n",i);
for (j=0;j<colum;j++)
{
printf("The type %c maxium system resource may needed:\n",'A'+j);
if(status==0)
{
maxhead=maxium1=maxium2=(struct max*)malloc(maxlen);
maxium1->next=maxium2->next=NULL;
scanf("%d",&maxium1->value);
status++;
}
else
{
maxium2=(struct max *)malloc(maxlen);
scanf("%d,%d",&maxium2->value);
if(status==1)
{
maxhead->next=maxium2;
status++;
}
maxium1->next=maxium2;
maxium1=maxium2;
}
}
}
maxium2->next=NULL;
status=0;
printf("Please enter the available array now exists in the system:\n");
for (j=0;j<colum;j++)
{
printf("The type %c available system resource number:\n",'A'+j);
if(status==0)
{
avahead=available1=available2=(struct available*)malloc(avalen);
workhead=work1=work2=(struct available*)malloc(avalen);
available1->next=available2->next=NULL;
work1->next=work2->next=NULL;
scanf("%d",&available1->value);
work1->value=available1->value;
status++;
}
else
{
available2=(struct available*)malloc(avalen);
work2=(struct available*)malloc(avalen);
scanf("%d,%d",&available2->value);
work2->value=available2->value;
if(status==1)
{
avahead->next=available2;
workhead->next=work2;
status++;
}
available1->next=available2;
available1=available2;
work1->next=work2;
work1=work2;
}
}
available2->next=NULL;
work2->next=NULL;
status=0;
alloctemp=allochead;
maxtemp=maxhead;
for(i=0;i<row;i++)
for (j=0;j<colum;j++)
{
if(status==0)
{
needhead=need1=need2=(struct need*)malloc(needlen);
need1->next=need2->next=NULL;
need1->value=maxtemp->value-alloctemp->value;
status++;
}
else
{
need2=(struct need *)malloc(needlen);
need2->value=(maxtemp->value)-(alloctemp->value);
if(status==1)
{
needhead->next=need2;
status++;
}
need1->next=need2;
need1=need2;
}
maxtemp=maxtemp->next;
alloctemp=alloctemp->next;
}
need2->next=NULL;
status=0;
for(i=0;i<row;i++)
{
if(status==0)
{
finihead=finish1=finish2=(struct finish*)malloc(finilen);
finish1->next=finish2->next=NULL;
finish1->stat=0;
status++;
}
else
{
finish2=(struct finish*)malloc(finilen);
finish2->stat=0;
if(status==1)
{
finihead->next=finish2;
status++;
}
finish1->next=finish2;
finish1=finish2;
}
}
finish2->next=NULL; /*Initialization compleated*/
status=0;
processtest=0;
for(temp=0;temp<row;temp++)
{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
for(i=0;i<row;i++)
{
worktemp1=worktemp;
if(finishtemp->stat==0)
{
for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next)
if(needtemp->value<=worktemp->value)
processtest++;
if(processtest==colum)
{
for(j=0;j<colum;j++)
{
worktemp1->value+=alloctemp->value;
worktemp1=worktemp1->next;
alloctemp=alloctemp->next;
}
if(status==0)
{
pathhead=path1=path2=(struct path*)malloc(pathlen);
path1->next=path2->next=NULL;
path1->value=i;
status++;
}
else
{
path2=(struct path*)malloc(pathlen);
path2->value=i;
if(status==1)
{
pathhead->next=path2;
status++;
}
path1->next=path2;
path1=path2;
}
finishtemp->stat=1;
}
else
{
for(t=0;t<colum;t++)
alloctemp=alloctemp->next;
finishtemp->stat=0;
}
}
else
for(t=0;t<colum;t++)
{
needtemp=needtemp->next;
alloctemp=alloctemp->next;
}
processtest=0;
worktemp=workhead;
finishtemp=finishtemp->next;
}
}
path2->next=NULL;
finishtemp=finihead;
for(temp=0;temp<row;temp++)
{
if(finishtemp->value==0)
{
printf("\nWARNING,the system is in nonsafe status!\n");
exit(0);
}
finishtemp=finishtemp->next;
}
printf("\nThe system is in safe status!\n");
printf("\nThe safe sequence is: \n");
do
{
printf("p%d ",pathhead->value);
}
while(pathhead=pathhead->next);
}

『叄』 銀行家演算法假定系統資源總量

按照3-6-1-2-4-5的順序分配。則Q已經運行完，P佔6個資源，R佔3個資源，剩餘2個資源。
如果資源數量為10個，系統會死鎖。因為按照如上的順序分配，P還需要2個資源，R還需要3個資源，但是剩餘資源為1個，系統將死鎖。

『肆』 操作系統題目,好的追加高分,感謝大蝦

http://tieba..com/f?kz=588380474

http://blog.163.com/mqt_signature/blog/static/1049595722009429104343122/

或者看看這個，可是你需要的

《操作系統--銀行家演算法》
課程設計報告

1 課程設計目的 …………………………………………………… 1
2 課程設計的要求 ………………………………………………… 1
3 課程設計題目描述 ……………………………………………… 2
4 課程設計之銀行家演算法原理 …………………………………… 2
5 源程序結構分析及代碼實現 …………………………………… 4
6 課程設計總結 …………………………………………………… 25
一、課程設計的目的
操作系統是計算機系統的核心系統軟體，它負責控制和管理整個系統的資源並組織用戶協調使用這些資源，使計算機高效的工作。《操作系統課程設計》是《操作系統》理論課的必要補充，是復習和檢驗所學課程的重要手段，本課程設計的目的是綜合應用學生所學知識，通過實驗環節，加深學生對操作系統基本原理和工作過程的理解，提高學生獨立分析問題、解決問題的能力，增強學生的動手能力。
二、課程設計的要求
1．分析設計內容，給出解決方案（要說明設計實現的原理，採用的數據結構）。
2．畫出程序的基本結構框圖和流程圖。
3．對程序的每一部分要有詳細的設計分析說明。
4．源代碼格式要規范。
5．設計合適的測試用例，對得到的運行結果要有分析。
6．設計中遇到的問題，設計的心得體會。
7．按期提交完整的程序代碼、可執行程序和課程設計報告。

三、課程設計題目描述
銀行家演算法是一種最有代表性的避免死鎖的演算法。
要解釋銀行家演算法，必須先解釋操作系統安全狀態和不安全狀態。
安全狀態：如果存在一個由系統中所有進程構成的安全序列P1，…，Pn，則系統處於安全狀態。安全狀態一定是沒有死鎖發生。
不安全狀態:不存在一個安全序列。不安全狀態不一定導致死鎖。
那麼什麼是安全序列呢？
安全序列：一個進程序列{P1，…，Pn}是安全的，如果對於每一個進程Pi(1≤i≤n），它以後尚需要的資源量不超過系統當前剩餘資源量與所有進程Pj (j < i )當前佔有資源量之和。
銀行家演算法：
我們可以把操作系統看作是銀行家，操作系統管理的資源相當於銀行家管理的資金，進程向操作系統請求分配資源相當於用戶向銀行家貸款。操作系統按照銀行家制定的規則為進程分配資源，當進程首次申請資源時，要測試該進程對資源的最大需求量，如果系統現存的資源可以滿足它的最大需求量則按當前的申請量分配資源，否則就推遲分配。當進程在執行中繼續申請資源時，先測試該進程已佔用的資源數與本次申請的資源數之和是否超過了該進程對資源的最大需求量。若超過則拒絕分配資源，若沒有超過則再測試系統現存的資源能否滿足該進程尚需的最大資源量，若能滿足則按當前的申請量分配資源，否則也要推遲分配。

四、課程設計之銀行家演算法原理
1．銀行家演算法的思路
先對用戶提出的請求進行合法性檢查，即檢查請求的是不大於需要的，是否不大於可利用的。若請求合法，則進行試分配。最後對試分配後的狀態調用安全性檢查演算法進行安全性檢查。若安全，則分配，否則，不分配，恢復原來狀態，拒絕申請。

2．銀行家演算法中用到的主要數據結構
可利用資源向量 int Available[j] j為資源的種類。
最大需求矩陣 int Max[i][j] i為進程的數量。
分配矩陣 int Allocation[i][j]
需求矩陣 int need[i][j]= Max[i][j]- Allocation[i][j]
申請各類資源數量 int Request i[j] i進程申請j資源的數量
工作向量 int Work[x] int Finish[y]

3．銀行家演算法bank()
進程i發出請求申請k個j資源，Request i[j]=k
(1)檢查申請量是否不大於需求量：Request i[j]<=need[i,j],若條件不符重新輸入，不允許申請大於需求量。
(2)檢查申請量是否小於系統中的可利用資源數量：Request i[j]<=available[i,j]，若條件不符就申請失敗，阻塞該進程，用goto語句跳轉到重新申請資源。
(3)若以上兩個條件都滿足，則系統試探著將資源分配給申請的進程，並修改下面數據結構中的數值：
Available[i,j]= Available[i,j]- Request i[j]；
Allocation[i][j]= Allocation[i][j]+ Request i[j]；
need[i][j]= need[i][j]- Request i[j]；
(4)試分配後，執行安全性檢查，調用safe()函數檢查此次資源分配後系統是否處於安全狀態。若安全，才正式將資源分配給進程；否則本次試探分配作廢，恢復原來的資源分配狀態，讓該進程等待。
(5)用do{…}while 循環語句實現輸入字元y/n判斷是否繼續進行資源申請。

4．安全性檢查演算法（safe()函數）
(1)設置兩個向量：
工作向量Work，它表示系統可提供給進程繼續運行所需的各類資源數目，在執行安全性演算法開始時，Work= Available。
Finish，它表示系統是否有足夠的資源分配給進程，使之運行完成。開始時先做Finish[i]=0；當有足夠的資源分配給進程時，再令Finish[i]=1。

(2)在進程中查找符合以下條件的進程：
條件1：Finish[i]=0；
條件2：need[i][j]<=Work[j]
若找到，則執行步驟(3)否則，執行步驟(4)

(3)當進程獲得資源後，可順利執行，直至完成，並釋放出分配給它的資源，故應執行：
Work[j]= Work[j]+ Allocation[i][j]；
Finish[i]=1；
goto step 2；

(4)如果所有的Finish[i]=1都滿足，則表示系統處於安全狀態，否則，處於不安全狀態。

五、源程序結構分析及代碼實現

1．程序結構

程序共有以下五個部分：

(1).初始化chushihua()：用於程序開始進行初始化輸入數據：進程數量、資源種類、各種資源可利用數量、各進程的各種資源已分配數量、各進程對各類資源最大需求數等。
(2).當前安全性檢查safe()：用於判斷當前狀態安全性，根據不同地方的調用提示處理不同。
(3).銀行家演算法bank()：進行銀行家演算法模擬實現的模塊，調用其他各個模塊進行銀行家演算法模擬過程。
(4).顯示當前狀態show()：顯示當前資源分配詳細情況，包括：各種資源的總數量(all)、系統目前各種資源可用的數量、各進程已經得到的資源數量、各進程還需要的資源量。
(5).主程序main()
逐個調用初始化、顯示狀態、安全性檢查、銀行家演算法函數，使程序有序的進行。

2．數據結構
程序使用的全局變數：
const int x=10，y=10； //定義常量
int Available[x]; //各種資源可利用的數量
int Allocation[y][y]; //各進程當前已分配的資源數量
int Max[y][y]; //各進程對各類資源的最大需求數
int Need[y][y]; //還需求矩陣
int Request[x]; //申請各類資源的數量
int Work[x]; //工作向量，表系統可提供給進程運行所需各類資源數量
int Finish[y]; //表系統是否有足夠的資源分配給進程，0為否，1為是
int p[y]; //存儲安全序列
int i,j; //全局變數，主要用於循環語句中
int n,m; //n為進程的數量,m為資源種類數
int l=0,counter=0;

3．函數聲明
void chushihua(); //系統初始化函數
void safe(); //安全性演算法函數
void bank(); //銀行家演算法函數
void show (); //輸出當前資源分配情況

4．主函數main()
int main()
{
cout<<…… //顯示程序開始提示信息
chushihua(); //初始化函數調用
cout<<endl<<endl;
showdata(); //輸出初始化後的狀態
//===判斷當前狀態的安全性===
safe(); //安全性演算法函數調用
if (l<n){
cout<<"\n當前狀態不安全，無法申請,程序退出!!!!!"<<endl;
cout<<endl;
system("pause");
sign(); //調用簽名函數
return 0; // break;
}
else{
int i; //局部變數
l=0;
cout<<"\n安全的狀態!!!"<<endl;
cout<<"安全序列為: ";
cout<<endl<<"進程"<<"("<<p[0]<<")"; //輸出安全序列，考慮顯示格式，先輸出第一個
for (i=1; i<n; i++){
cout<<"==>>"<<"進程"<<"("<<p[i]<<")";
}
for (i=0; i<n; i++) Finish[i]=0; //所有進程置為未分配狀態
cout<<endl<<endl;
}
bank(); //銀行家演算法函數調用
return 0;
}

5. 操作系統銀行家演算法流程圖：

2.源程序代碼：
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//定義全局變數
const int x=10,y=10; //常量，便於修改
int Available[x]; //各資源可利用的數量
int Allocation[y][y]; //各進程當前已分配的資源數量
int Max[y][y]; //各進程對各類資源的最大需求數
int Need[y][y]; //尚需多少資源
int Request[x]; //申請多少資源
int Work[x]; //工作向量，表示系統可提供給進程繼續運行所需的各類資源數量
int Finish[y]; //表示系統是否有足夠的資源分配給進程，1為是
int p[y]; //存儲安全序列
int i,j; //i表示進程，j表示資源
int n,m; //n為進程i的數量,m為資源j種類數
int l=0; //l用來記錄有幾個進程是Finish[i]=1的，當l=n是說明系統狀態是安全的
int counter=0;

//函數聲明
void chushihua(); //初始化函數
void safe(); //安全性演算法
void show(); //函數show,輸出當前狀態
void bank(); //銀行家演算法
void jieshu(); //結束函數

void chushihua()
{
cout<<"輸入進程的數量: ";//從此開始輸入有關數據
cin>>n;
cout<<"輸入資源種類數: ";
cin>>m;
cout<<endl<<"輸入各種資源當前可用的數量( "<<m<<" 種): "<<endl;
for (j=0; j<m; j++)
{
cout<<"輸入資源 "<<j<<" 可利用的數量Available["<<j<<"]: ";
cin>>Available[j]; //輸入數字的過程...
Work[j]=Available[j]; //初始化Work[j]，它的初始值就是當前可用的資源數
}

cout<<endl<<"輸入各進程當前已分配的資源數量Allocation["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 輸入進程 "<<i<<" 當前已分配的資源 "<<j<<" 數量: ";
cin>>Allocation[i][j];
}
cout<<endl;
Finish[i]=0;//初始化Finish[i]
}

cout<<endl<<"輸入各進程對各類資源的最大需求Max["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 輸入進程 "<<i<<" 對資源 "<<j<<" 的最大需求數: ";
cin>>Max[i][j];
if(Max[i][j]>=Allocation[i][j]) //若最大需求大於已分配，則計算需求量
Need[i][j] = Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;//Max小於已分配的時候，此類資源已足夠不需再申請
}
cout<<endl;
}
cout<<endl<<"初始化完成"<<endl;
}

//安全性演算法函數
void safe()
{
l=0;
for (i=0; i<n;i++)
{ //i++
if (Finish[i]==0)
{ //逐個查找Finish[i]==0的進程 條件一
counter=0; //記數器

for (j=0; j<m; j++)
{
if (Work[j]>=Need[i][j]) counter=counter+1;//可用大於需求，記數
}

if(counter==m) //i進程的每類資源都符合Work[j]>=Need[i][j] 條件二
{
p[l]=i; //存儲安全序列
Finish[i]=1; //i進程標志為可分配
for (j=0; j<m;j++)
Work[j]=Work[j]+Allocation[i][j]; //釋放資源
l=l+1; //記數,現在有L個進程是安全的，當L=N時說明滿足安全序列
i= -1; //從第一個進程開始繼續尋找滿足條件一二的進程
}
}
}
}

//顯示當前狀態函數
void show() //函數show,輸出當前資源分配情況
{
int i,j; //局部變數
int All[y]; //各種資源的總數量
int L1; //局部變數L1

cout<<"當前的狀態為："<<endl;
cout<<"各種資源的總數量:"<<endl;
for (j=0;j<m;j++)
{
cout<<" 資源"<<j<<": ";
All[j]=Available[j]; //總數量=可用的+已分配的
for (i=0;i<n;i++) All[j]+=Allocation[i][j];

cout<<All[j]<<" ";
}

cout<<endl<<"當前各種資源可用的量為(available):"<<endl;
for (j=0;j<m;j++)
cout<<" 資源"<<j<<": "<<Available[j]<<" ";

cout<<endl<<"各進程已經得到的資源量(allocation): "<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 資源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"進程"<<L1<<":";
for (j=i;j<m;j++) cout<<Allocation[L1][j]<<" ";
cout<<endl;
}
}

cout<<endl<<"各進程還需要的資源量(need):"<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 資源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"進程"<<L1<<":";
for (j=i;j<m;j++) cout<<Need[L1][j]<<" ";
cout<<endl;
}
}
}

//銀行家演算法函數
void bank()
{
cout<<endl<<"進程申請分配資源："<<endl;

int k=0; //用於輸入進程編號
bool r=false; // 初值為假，輸入Y繼續申請則置為真
do{//輸入請求
cout<<"輸入申請資源的進程(0-"<<n-1<<"): ";
cin>>k;
cout<<endl;
while(k>n-1) //輸入錯誤處理
{
cout<<endl<<"輸入錯誤，重新輸入："<<endl;
cout<<endl<<"輸入申請資源的進程(0--"<<n-1<<"): ";
cin>>k;
cout<<endl;
}
cout<<endl<<"輸入該進程申請各類資源的數量: "<<endl;
for (j=0; j<m; j++)
{
do{ //do……while 循環判斷申請輸入的情況
cout<<"進程 "<<k<<" 申請資源["<<j<<"]的數量:";
cin>>Request[j];
cout<<endl;
if(Request[j]>Need[k][j]){ //申請大於需求量時出錯，提示重新輸入（貸款數目不允許超過需求數目）
cout<<"申請大於需要量!"<<endl;
cout<<"申請的資源"<<j<<"的數量為"<<Request[j]<<",大於進程"<<k<<"對該資源需求量"<<Need[k][j]<<"。"<<endl;
cout<<"重新輸入!"<<endl;
}
else //先判斷是否申請大於需求量，再判斷是否申請大於可利用量
if(Request[j]>Available[j]){ //申請大於可利用量， 應該阻塞等待？…… ？？？
cout<<"\n沒有那麼多資源，目前可利用資源"<<j<<"數量為"<<Available[j]<<",本次申請不成功，進程等待!"<<endl;
Finish[k]=0; //該進程等待
goto ppp; //goto語句 跳轉，結束本次申請
}
}while(Request[j]>Need[k][j]); //Request[j]>Available[j]||
}

//改變Avilable、Allocation、Need的值
for (j=0; j<m; j++) {
Available[j] = Available[j]-Request[j];
Allocation[k][j] = Allocation[k][j]+Request[j];
Need[k][j] = Need[k][j]-Request[j];
Work[j] = Available[j];
}
//判斷當前狀態的安全性
safe(); //調用安全性演算法函數
if (l<n)
{
l=0;
cout<<"\n試分配後，狀態不安全,所以不予分配!恢復原狀態"<<endl;
//恢復數據
for (j=0; j<m; j++)
{
Available[j] = Available[j]+Request[j];
Allocation[k][j] = Allocation[k][j]-Request[j];
Need[k][j] = Need[k][j]+Request[j];
Work[j] = Available[j];
}
for (i=0; i<n; i++)
Finish[i]=0; //進程置為未分配狀態
}
else
{
l=0;
cout<<"\n申請資源成功!!!"<<endl;

for(j=0;j<m;j++)
{
if(Need[k][j]==0);
else { //有一種資源還沒全部申請到，則該進程不可執行，不能釋放擁有的資源
l=1; //置l為1，作為判斷標志
break;
}
}
if(l!=1){ //進程可以執行，則釋放該進程的所有資源
for (j=0;j<m;j++){
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
}
cout<<"該進程已得到所有需求資源，執行後將釋放其所有擁有資源！"<<endl;
}
l=0; //歸零

cout<<"\n安全的狀態!"<<endl;
cout<<"安全序列為: ";
cout<<endl<<"進程"<<"("<<p[0]<<")"; //輸出安全序列，考慮顯示格式，先輸出第一個
Finish[0]=0;
for (i=1; i<n; i++){
cout<<"==>>"<<"進程"<<"("<<p[i]<<")";
Finish[i]=0; //所有進程置為未分配狀態
}
cout<<endl<<endl;
}
show(); //顯示當前狀態
ppp: //申請大於可利用量， 應該阻塞等待,結束本次資源申請，GOTO 語句跳轉至此
cout<<endl<<"是否繼續申請資源(y/n) ?";
char* b=new char; //輸入y/n，判斷是否繼續申請 <<endl
cin>>b;
cout<<endl;
cout<<"-------------------------------------------"<<endl<<endl;
cout<<endl;
if(*b=='y'||*b=='Y')
r=true;
else{
r=false; //輸入非 Y 則令 R =false
jieshu(); //調用結束函數
}
} while (r==true);
}

//結束函數
void jieshu()
{
cout<<endl<<endl;
cout<<"\t\t 演示計算完畢"<<endl;
cout<<endl<<endl;
}

//主函數
int main()
{
cout<<endl<<endl<<"\t\t\t\t模擬銀行家演算法"<<endl<<endl;
chushihua(); //初始化函數調用
cout<<endl;
show(); //輸出當前狀態
safe(); //判斷當前狀態的安全性
if (l<n) //l在safe中是用來記錄安全的進程的個數的
{
cout<<"\n當前狀態不安全，拒絕申請！"<<endl;
cout<<endl;
return 0;
}
else
{
int i; //局部變數
l=0;
cout<<endl<<"\n當前的狀態是安全的!安全序列為:"<<endl;
cout<<"進程"<<"("<<p[0]<<")"; //輸出安全序列
for (i=1; i<n; i++) cout<<"->>"<<"進程"<<"("<<p[i]<<")";
for (i=0; i<n; i++) Finish[i]=0; //所有進程置為未分配狀態
cout<<endl;
}

bank(); //調用銀行家演算法函數
cout<<"\t\t 演示計算完畢"<<endl;
return 0;
}

運行結果：
1.初始化結果
2.檢測系統資源分配是否安全結果：

六、課程設計的總結
操作系統的基本特徵是並發與共享。系統允許多個進程並發執行，並且共享系統的軟、硬體資源。為了最大限度的利用計算機系統的資源，操作系統應採用動態分配的策略，但是這樣就容易因資源不足，分配不當而引起「死鎖」。而我本次課程設計就是得用銀行家演算法來避免「死鎖」。銀行家演算法就是一個分配資源的過程，使分配的序列不會產生死鎖。此演算法的中心思想是：按該法分配資源時，每次分配後總存在著一個進程，如果讓它單獨運行下去，必然可以獲得它所需要的全部資源，也就是說，它能結束，而它結束後可以歸還這類資源以滿足其他申請者的需要。
本次程序就是按照上面的思路展開的。但是因為時間上的倉促，本課程設計的存在著以下不足：一、不能實現並發操作，即當總資源同時滿足幾個進程所需要的資源數時，這些進程不能同時進行，只能一一按進程順序執行。二、掃描進程順序單一，只能按進程到來的順序（即編號）來掃描，從而產生的安全順序只能是在這個順序的基礎上產生的，而其實安全順序是有多個的。三、對進程數和資源數進行的數量進行了限制，都只能最多有十個。四、運行程序後，界面較差，進程數，所需要資源數，已分配資源數，能用資源數，不能一目瞭然。
這次課程設計時間上雖說倉促點，但是我依然學到了很多的實用性知識。除了更深的了解這個演算法，而且對C語言進行了復習，而且其過程中有很多的知識點都不記得了，所以在此感謝在此過程中幫助過我的老師和同學。
最後的感悟就是：只要你親自動手，你就能學到知識。
再次感謝幫助過我的老師和同學！

『伍』 計算機408有多難

408的全稱是「408計算機專業基礎綜合」，是計算機專業/軟體工程等專業的統考科目。與其他統考科目不同，計算機408比絕大多數學校的自主命題都要難很多。

計算機專業基礎綜合考試，考試代碼是408，總共涉及四門專業課的考察，分別是數據結構、計算機組成原理、操作系統和計算機網路。

試卷內容結構：

• 數據結構 45分

• 計算機組成原理 45分

• 操作系統35分

• 計算機網路 25

對於408的難度，一個很明顯的事實就是，採用408作為考試科目的學校，分數線都不高（相對不高)。

但是，隨著普及，408難度的降低可能是一種趨勢，畢竟考研是一場選拔性考試，主要目的是篩選考生，而不是難倒考生。而重新歸來的408統考，可能也會爭取成為受眾更廣的統考科目。

• 計算機網路★★★

考試內容主要圍繞TCP/IP協議層次的具體展開，包括以下內容：物理層、數據鏈路層、網路層、傳輸層、應用層。

計算機網路這門課的特點是：在考研專業課中所佔分數最少，但是涉及到的具體的知識點最多。

考生復習時要注意按照層進行知識點的復習和總結。對於每一層，重點把握這一層的協議有哪些、引入這些協議的原因、涉及到哪些重要演算法、演算法的內容、每一層和上下層之間的關系、每一層用到的硬體設備及作用等，也就是說，學習完一層時一定要用系統的方法將具體的知識點串連在一起，不要局限於孤立地理解和掌握每個細節的知識點。

這四門專業課之間有一定的內在聯系，數據結構和組成原理是操作系統的先修課程，計算機網路相對來說比較獨立，或者說不需要先修課程。

內容的交叉有一些，主要表現在組成原理和操作系統這兩門專業課之間，二者都包含了存儲系統和輸入/輸出系統的內容，如：內存管理的各種頁面置換演算法、虛擬存儲器等。

如果不是跨專業考生，也就是說這些專業課以前都系統的學習過，那麼復習時可以不按順序。但如果是初學者，必須先學習完數據結構和組成原理後再學習操作系統，否則有些概念和原理難以理解。

四門課的復習時間應該合理分配，重點放在數據結構和組成原理上，尤其數據結構更要多花一些時間;操作系統和計算機網路的很多知識點需要在理解的基礎上進行記憶，相對來說容易一些。當然難易程度是相對的，具體情況也要因人而異，靈活安排。

『陸』 C編程完成銀行家演算法的進程調度及同步模擬的實現

#include<stdio.h>
voidrukou(intjinchenggeshu,intziyuangeshu)
{
inti,j,k=0;
intzanyong[100][100];
intxuqiuzuida[100][100];
intxuyaoziyuangeshu[100][100];
intmeizhongziyuangeshu[100];
intmeizhongzuyuanshengyugeshu[100];
intjieguo[100];
intshifouanquan=0;
intkongshu;
intgaibianshuju;
intyongyouziyuanjishu;
for(i=0;i<jinchenggeshu;i++)
for(j=0;j<ziyuangeshu;j++)
{
printf("
請輸入第%d進程現在佔用第%d種資源的個數：",i+1,j+1);
scanf("%d",&zanyong[i][j]);
}
for(i=0;i<jinchenggeshu;i++)
for(j=0;j<ziyuangeshu;j++)
{
printf("
請輸入第%d進程現在所需最大第%d種資源的個數：",i+1,j+1);
scanf("%d",&xuqiuzuida[i][j]);
}
for(i=0;i<ziyuangeshu;i++)
{
printf("
請輸入第%d種資源的個數：",i+1);
scanf("%d",&meizhongziyuangeshu[i]);
}
printf("如果有輸入錯誤想改變
");
gaibian:printf("想改變佔用的數據請輸入1
");
printf("想改變最大資源需求量的數據請輸入2
");
printf("想改變資源中的數據請輸入3
");
printf("退出改變數據請輸入4
");
scanf("%d",&gaibianshuju);
if(gaibianshuju==1)
{
printf("請輸入改變哪個進程中的數據：");
scanf("%d",&i);
printf("請輸入改變哪種資源中的數據：");
scanf("%d",&j);
printf("請輸入新數據：");
scanf("%d",&zanyong[i][j]);
gotogaibian;
}
elseif(gaibianshuju==2)
{
printf("請輸入改變哪個進程中的數據：");
scanf("%d",&i);
printf("請輸入改變哪種資源中的數據：");
scanf("%d",&j);
printf("請輸入新數據：");
scanf("%d",&xuyaoziyuangeshu[i][j]);
gotogaibian;
}
elseif(gaibianshuju==3)
{
printf("請輸入改變哪種資源中的數據：");
scanf("%d",&j);
printf("請輸入新數據：");
scanf("%d",&meizhongziyuangeshu[j]);
gotogaibian;
}
elseif(gaibianshuju==4);
else{
printf("您選擇的無效，請從新選擇
：");
gotogaibian;
}
for(i=0;i<jinchenggeshu;i++)
for(j=0;j<ziyuangeshu;j++)
xuyaoziyuangeshu[i][j]=xuqiuzuida[i][j]-zanyong[i][j];
for(j=0;j<ziyuangeshu;j++)
{
yongyouziyuanjishu=0;
for(i=0;i<jinchenggeshu;i++)
yongyouziyuanjishu+=zanyong[i][j];
meizhongzuyuanshengyugeshu[j]=meizhongziyuangeshu[j]-yongyouziyuanjishu;
}
while(1)
{
shifouanquan++;
for(i=0;i<jinchenggeshu;i++)
{
if(zanyong[i][0]!=-1)
{
kongshu=0;
for(j=0;j<ziyuangeshu;j++)
if(meizhongzuyuanshengyugeshu[j]>=xuyaoziyuangeshu[i][j])
kongshu+=1;
if(kongshu==ziyuangeshu)
{
for(j=0;j<ziyuangeshu;j++)
meizhongzuyuanshengyugeshu[j]+=zanyong[i][j];
zanyong[i][0]=-1;
jieguo[k]=i+1;
k++;
}
}
}
if(k==jinchenggeshu)
{
printf("T0時刻是安全狀態，安全序列為：");
for(i=0;i<jinchenggeshu;i++)
printf("%d",jieguo[i]);
break;
}
if(shifouanquan>k)
{
printf("T0時刻是不安全狀態!");
break;
}
}
}
intmain()
{
intjinchenggeshu,ziyuangeshu;
printf("請輸入進程個數：");
scanf("%d",&jinchenggeshu);
printf("請輸入資源種類數:");
scanf("%d",&ziyuangeshu);
rukou(jinchenggeshu,ziyuangeshu);
return0;
}

『柒』 網路操作系統習題求解

1. 19+2+15=36min 19+2=21min
2. 程序，數據，進程式控制制塊PCB三部分組成。 PCB是進程存在的唯一標志
3. CPU時間
4. 需要互斥執行的程序段
5. p p
6. 進程擁有此信號量
7. 信箱頭 信箱體
8. 低級 高級
9. 產生死鎖的4個必要條件是互斥、非剝奪、部分分配和 循環等待
10.資源有序分配策略
11. 安全狀態 不安全狀態
12. 線程的內核對象 線程堆棧
13. 產生（New），可執行（Runnable），死亡（Dead），停滯（Blocked）
14. 進程獲取到所需資源時
15. D
16. 可執行
17. 1
18. 執行條件得到滿足
19. 指令
20. 進程間的通信
21. 任何一個進程都可以申請進入臨界區
22. 就緒態
23. 10

『捌』 有三個線程 需要的資源個數是2 3 4 問 最少給多少個資源 才不會發生死鎖

按照你的做法,如果這時候系統給進程1一個資源,給進程2一個資源,
那樣系統就會死鎖.而你們老師說的就是正確的,因為無論系統把那一個
資源給任意一個進程,任意一個進程都會完成並釋放資源.

『玖』 1．考慮某一系統，它有4類資源R1,R2,R3,R4，有5個並發進程P0,P1,P2,P3,P4，按照銀行家演算法回答下列問題。

P0->P2->P3->P1->P4