银行家算法
资源下载（文档及代码等）：https://download.csdn.net/download/fufuyfu/85511576?spm=1001.2014.3001.5503
一、实验内容
用银行家算法避免死锁，实现系统合理分配资源，加深对进程同步及死锁理解。
二、实验要求
1、假定系统有3类资源A（10个）、B（15个）、C（12个），系有5个进程并发执行，进程调度采用时间片轮转调度算法。
2、每个进程由一个进程控制块（PCB）表示，进程控制块可以包含如下信息：进程名、需要的资源总数、已分配的资源数、进程状态。
3、由程序自动生成进程（包括需要的数据，要注意数据的合理范围）。
4、进程在运行过程中会随机申请资源（随机生成请求的资源数），如果达到最大需求，表示该进程可以完成；如果没有达到最大需求，则运行一个时间片后，调度其它进程运行。资源分配采用银行家算法来避免死锁。
5、每个进程的状态可以是就绪W（Wait）、运行R（Run）、阻塞B（Block）或完成F（Finish）状态之一。
6、每进行一次调度，程序都要输出一次运行结果：正在运行的进程、就绪队列中的进程、阻塞队列中的进程、完成的进程以及各个进程的PCB，以便进行检查。
三、算法流程
3.1 头文件和数据结构
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define TIME_SLICE 2
// 进程状态：就绪 等待 阻塞 完成
enum process_type{
process_type_wait = 'W',
process_type_run = 'R',
process_type_block = 'B',
process_type_finish = 'F'
};
typedef struct PCB{
// 进程名
char name;
// 最大需求资源数
int Max[100];
// 还需要的资源数
int Need[100];
// 已分配的资源数
int Allocate[100];
// 进程已运行时间
int run_time;
// 进程状态
char state;
// 指向下一个进程
PCB *next;
}PCB;
// 系统资源的名称
char Name[100]={0};
// 系统可用资源向量
int Available[100];
// 进程请求资源向量
int Request[100];
// 存放系统可提供资源量
int Work[100];
// 标记系统是否有足够的资源分配给各个进程
bool Finish[100];
// 存放安全序列
char Security[100];
// 进程的最大数
int M = 100;
// 资源的最大数
int N = 100;
// 标志是否输出
bool flag = true;
// 函数声明
// 初始化数据
void init(PCB *list);
// 创建进程
void create_process(PCB *list);
// 显示资源分配和进程运行情况
void print(PCB *list);
// 试探性分配资源
void test(PCB *list);
// 试探性分配资源作废
void Retest(PCB *list);
// 利用银行家算法对申请资源进行试分
bool bank(PCB *list);
// 安全性算法
bool safe(PCB *list);
// 时间片轮转调度算法
void round_robin(PCB *list);
3.2 主函数
// 主函数
int main(){
printf("-----------------------------------------------------------------------\n");
printf("|| 银行家算法的实现 ||\n");
printf("-----------------------------------------------------------------------\n\n");
PCB *list = (PCB *)malloc(sizeof(PCB));
if(list == NULL){
printf("动态分配内存失败！");
}
list->next = NULL;
srand((int)time(NULL));
// 初始化数据
init(list);
// 显示资源分配和进程运行情况
printf("***********************************************************************\n");
print(list);
// 用银行家算法判定系统当前时刻是否安全，不安全就不再继续分配资源
if(!safe(list)) {
exit(0);
}
printf("\n***********************************************************************\n");
// 使用时间片轮转法进行进程调度
round_robin(list);
}
3.3 初始化数据
// 初始化数据
void init(PCB *list){
// m为进程数，n为系统资源种类
int m,n;
// 初始化系统资源种类数及各资源数
printf("系统可用资源种类数为：");
scanf("%d",&n);
// 系统资源种类数，赋给全局变量N，方便后续方法使用
N = n;
// 资源名称
char name;
// 资源数
int number;
for(int i = 1;i <= n;i++){
printf("\t资源%d的名称：",i);
getchar();
scanf("%c",&name);
Name[i] = name;
printf("\t资源%c的初始个数为：",name);
scanf("%d",&number);
Available[i] = number;
}
// 初始化进程数及各进程的最大需求资源数
printf("\n请输入进程的数量：");
scanf("%d",&m);
// 进程数，赋给全局变量M，方便后续方法使用
M = m;
create_process(list);
}
3.4 创建进程
// 创建进程
void create_process(PCB *list){
// 统计已分配的系统资源
int temp[100] = {0};
int number = 1;
while(number <= M){
// 进程节点
PCB *p = (PCB *)malloc(sizeof(PCB));
if(p == NULL){
printf("动态分配内存失败！");
}
// 进程名
printf("\t请输入第%d进程的进程名：",number);
getchar();
scanf("%c",&p->name);
// 标志变量
bool flag;
// 初始化各进程最大需求资源数、仍需资源数和已分配资源数
do{
flag = false;
for(int i = 1;i <= N;i++){
p->Max[i] = rand()%10;
if(p->Max[i] > Available[i]){
flag = true;
// printf("资源最大需求量大于系统中资源最大数，请重新输入!\n");
break;
}
p->Need[i] = p->Max[i];
p->Allocate[i] = 0;
}
}while(flag);
// 进程已运行时间
p->run_time = 0;
// 进程状态
p->state = process_type_wait;
// 指向下一个进程
p->next = NULL;
if(list->next == NULL){
list->next = p;
}else{
PCB *move = list->next;
while(move->next != NULL){
move = move->next;
}
move->next = p;
}
number++;
}
printf("\n");
}
3.5 显示资源分配和进程运行情况
// 显示资源分配和进程运行情况
void print(PCB *list){
printf("\n系统目前可用的资源(Available):\n");
for(int i = 1;i <= N;i++){
printf("%c ",Name[i]);
}
printf("\n");
for(int i = 1;i <= N;i++){
printf("%d ",Available[i]);
}
printf("\n\n");
printf("系统当前的资源分配情况及进程运行情况如下：\n");
printf(" Max Allocate Need\n");
printf("进程名 ");
//输出与进程名同行的资源名，Max、Allocate、Need下分别对应
for(int i = 1;i <= 3;i++){
for(int j = 1;j <= N;j++){
printf("%c ",Name[j]);
}
printf(" ");
}
printf("已运行时间 进程状态\n");
// 遍历链表
PCB *p = list->next;
while(p != NULL){
//输出每个进程的Max、Allocation、Need
printf(" %c\t",p->name);
for(int j = 1;j <= N;j++)
printf("%d ",p->Max[j]);
printf(" ");
for(int j = 1;j <= N;j++)
printf("%d ",p->Allocate[j]);
printf(" ");
for(int j = 1;j <= N;j++)
printf("%d ",p->Need[j]);
printf(" ");
printf(" %d\t ",p->run_time);
printf("%c\n",p->state);
p = p->next;
}
}
3.6 试探性分配资源
// 试探性分配资源
void test(PCB *list){
// 请求资源的进程
PCB *p = list->next;
// 更改进程信息
for(int i = 1;i <= N;i++){
Available[i] -= Request[i];
p->Allocate[i] += Request[i];
p->Need[i] -= Request[i];
}
}
3.7 试探性分配资源作废
// 试探性分配资源作废
void Retest(PCB *list){
// 请求资源的进程
PCB *p = list->next;
// 与test操作相反
for(int i = 1;i <= N;i++){
Available[i] += Request[i];
p->Allocate[i] -= Request[i];
p->Need[i] += Request[i];
}
}
3.8 利用银行家算法对申请资源进行试分
// 利用银行家算法对申请资源进行试分
bool bank(PCB *list){
PCB *p = list->next;
// 随机生成请求向量
for(int i = 1;i <= N;++i){
Request[i] = rand()%(p->Need[i]+1);
}
// 随机产生的请求资源数均为0，表示不理会
int n = 0;
for(int i = 1;i <= N;++i){
if(Request[i] == 0){
n++;
}
}
if(n == N){
flag = false;
return false;
}
printf("\n%c进程请求 —— ",p->name);
for(int i = 1;i <= N;i++){
printf("资源%c：",Name[i]);
printf("%d ",Request[i]);
}
printf("\n\n");
// 定位要求的资源数组下标
int num = 1;
// 判断银行家算法的前两条件是否成立
for(int i = 1;i <= N;++i){
// 判断申请是否大于需求，若大于则出错
if(Request[i] > p->Need[i]){
printf("%c进程申请的资源大于它需要的资源\n",p->name);
printf("分配不合理，不予分配！\n");
return false;
}else{
// 判断申请是否大于当前可分配资源，若大于则出错
if(Request[i] > Available[i]){
printf("%c进程申请的资源大于系统现可利用的资源\n",p->name);
printf("系统尚无足够资源，不予分配!\n");
return false;
}
}
}
// 前两个条件成立，试分配资源，寻找安全序列
// 根据进程需求量,试分配资源
test(list);
// 判断系统是否安全
if(!safe(list)){
Retest(list);
return false;
}
return true;
}
3.9 安全性算法
// 安全性算法
bool safe(PCB *list){
// 统计未完成进程数
int m = 0;
PCB *move = list->next;
while(move != NULL && move->state != process_type_finish){
move = move->next;
++m;
}
// 初始化Work数组
for(int i = 1;i <= N;i++){
Work[i] = Available[i];
}
// 初始化Finish数组
for(int i = 1;i <= M;i++){
if(i <= m){
Finish[i] = false;
}else{
Finish[i] = true;
}
}
// 节点位置，判断进程运行
int pnum = 1,apply;
int num = 1;
// 求安全序列
PCB *p = list->next;
while(p != NULL && pnum <= m){
apply = 0;
for(int i = 1;i <= N;i++){
// 当前进程未完成并且各类资源小于或等于系统资源数
if(Finish[pnum] == false && p->Need[i] <= Work[i]){
apply++;
// 直到每类资源尚需数都小于系统可利用资源数才可分配
if(apply == N){
for(int x = 1;x <= N;x++){
// 更新当前系统可分配资源
Work[x] += p->Allocate[x];
}
// 更新标记数组
Finish[pnum] = true;
// 更新安全序列数组
Security[num++] = p->name;
// 保证每次查询均从第一个进程开始
pnum = 0;
p = list;
}
}
}
// 查询下一进程
pnum++;
p = p->next;
}
for(int i = 1;i <= M;i++){
if(Finish[i] == false){
// 系统处于不安全状态
printf("系统不安全！\n");
return false;
}
}
// 如果安全，输出安全序列
printf("系统是安全的！\n");
printf("存在一个安全序列:");
for(int i = 1;i <= m;i++){
// 输出进程运行顺序数组
printf(" %c ",Security[i]);
if(i < m){
printf("->");
}
}
printf("\n");
return true;
}
3.10 时间片轮转调度算法
// 时间片轮转调度算法
void round_robin(PCB *list){
// 记录第一个结点的位置
PCB *index = list->next;
while (index != NULL && index->state != process_type_finish) {
// 判断调度后是否输出
flag = true;
// 系统安全，进程分配到资源并运行
if(bank(list)){
// 更新已运行时间
index->run_time += TIME_SLICE;
// 判断该进程是否完成
int num = 0;
for(int i = 1;i <= N;++i){
if(index->Max[i] == index->Allocate[i]){
num++;
}
}
// 该进程已完成
if (num == N) {
// 修改进程状态
index->state = process_type_finish;
// 回收分配的资源
for(int i = 1;i <= N;i++){
Available[i] += index->Allocate[i];
}
printf("%c进程完成\n",index->name);
}else{
// 进程未完成，进入等待
index->state = process_type_wait;
}
// 当前进程已完成
if (index->state == process_type_finish){
// 将已完成进程调整到已完成队列末尾
// 1.头指针指向首元结点的下一个结点
list->next = index->next;
// 2.遍历整个链表，将其插入到已完成队列的最尾端
PCB *p = list;
while (p->next != NULL) {
p = p->next;
}
p->next = index;
index->next = NULL;
} else {
// 当前进程未完成
// 1.头指针指向首元结点的下一个结点
list->next = index->next;
// 2.遍历整个链表，将其插入到等待队列的最尾端(其后是已完成队列)
PCB *p = list;
// 2.1寻找插入位置
while (p->next != NULL && p->next->state != process_type_finish) {
p = p->next;
}
// 2.2判断插入位置
if (p->next == NULL) {
// 最后一个
p->next = index;
p->next->next = NULL;
}else{
// 不是最后一个，其后仍有结点
index->next = p->next;
p->next = index;
}
}
}else{
// 该进程请求资源分配会导致系统不安全或请求资源不合理
// 将该进程阻塞并调整到等待队列和已完成队列中间，且是阻塞队列的最后一个
index->state = process_type_block;
// 当前进程未完成并处于阻塞状态
// 1.头指针指向首元结点的下一个结点
list->next = index->next;
// 2.遍历整个链表，将其插入到未完成队列后阻塞队列的最后一个
PCB *p = list;
// 2.1寻找插入位置
while (p->next != NULL && p->next->state != process_type_finish) {
p = p->next;
}
// 2.2判断插入位置
if (p->next == NULL) {
// 最后一个
p->next = index;
p->next->next = NULL;
}else{
// 不是最后一个，其后仍有结点
index->next = p->next;
p->next = index;
}
}
// 展示当前队列状况
if(list->next->state != process_type_finish){
list->next->state = process_type_run;
}
if(flag){
print(list);
printf("\n***********************************************************************\n");
}
index = list->next;
}
}
四、实验结果（截图）：
代码注释非常详尽，可自行运行，实验截图可自行运行截图
五、分析：
该实验中使用时间片轮转调度算法对随机生成的多个进程进行调度，其中的银行家算法先对进程提出的资源请求进行合法性检查，即检查请求的是否不大于进程需要的或系统可利用的。若请求合法，则进行试分配。最后对试分配后的状态调用安全性算法进行安全性检查。若系统安全，即存在一个安全的执行序列，只要系统按此进程序列分配进程所有所需资源，就能使每个进程都顺利执行，则分配，否则，不分配，恢复原来状态，拒绝申请。如此，系统在进行资源分配时，系统能够不进入不安全状态，能很好的避免死锁。
该实验所写代码较为冗余，可以通过修改所使用的数据结构对其进行优化，比如将PCB结构体中的最大需求资源数组Max、尚需资源数组Need和已分配资源数组Allocate更换为三个结构体指针，即建立一个资源结构体，其中包含系统的各种资源变量，而三个结构体指针则是指向该结构体，这样可以很好的对代码进行优化，但同时也存在一个小缺点，即无法手动输入资源种类数，需提前在代码中设定好，当需更改资源种类数时，需更改源代码，这样就不是非常符合OOP原则（对扩展开放，对修改关闭）。因此，在本实验未使用，但如果有方法对该数据结构再次进行优化解决此问题，该数据结构是更优的选择。
1320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
