银行家算法安全序列c语言代码,银行家算法-求所有安全序列

本文介绍了如何使用C语言实现银行家算法,寻找所有安全序列。通过深度优先搜索遍历,更新数据结构如Available、Allocation、Max、Need等,检查资源分配并构造安全序列。核心代码包括检查资源可用性、安全序列状态更新和回溯过程。
摘要由CSDN通过智能技术生成

银行家算法-求所有安全序列

使用DFS(深度优先搜索)遍历求出所有的安全序列。

数据结构

先上头文件说明,实现此算法用到的数据结构和命名。

#ifndef _DATA_STRUCTURE

#define _DATA_STRUCTURE

// 表示资源个数

#define M (4)

// 表示进程个数

#define N (4)

// 当前状态还剩多少可用的资源

struct AvailableD;

// 每个进程对每个资源的最大需求量

struct MaxD;

// 当前分配个每个进程的资源数目

struct AllocationD;

// 每个进程还需要多少资源数目(最大需求 - 当前分配)

struct NeedD;

// 当前状态每个进程请求的资源数量

struct RequestD;

// 存放安全序列的数据结构(名字叫 Queue 实际上是栈的实现【FILO先进后出】)

struct QueueD;

// 表明每个进程是否在安全序列中

struct StatusD;

typedef struct AvailableD *Available;

typedef struct MaxD *Max;

typedef struct AllocationD *Allocation;

typedef struct NeedD *Need;

typedef struct RequestD *Request;

typedef struct QueueD *Queue;

typedef struct StatusD *Status;

Available create_available();

Allocation create_allocation();

Max create_max();

Need create_need();

Queue create_queue();

int queue_full(Queue queue);

int queue_empty(Queue queue);

void queue_add(Queue queue, int data);

int queue_get(Queue queue);

void queue_display(Queue queue);

Status create_status();

void display_need(Need need);

/* 更新 need 数组 */

void update_need(Need need, Allocation allocation, Max max);

/* 将 allocation 矩阵的 第 row 行的值加(减)到 available 里 */

void update_available(Allocation allocation, int row, Available available, int is_add);

/* 检查 available 是否满足 need 的第 row 行的需求 */

void check_available(Allocation allocation, Need need, Available available, int row, Queue queue, Status status);

#endif

算法步骤

首先检查当前剩余的资源数目是否满足某个进程的需求量,也就是说判断 Available 向量中每一个资源数目是否大于等于 Need 矩阵中某一个进程的需求量;

如果对于进程 row ,对每个资源数目的需求量小于当前可用的系统资源;首先检查当前进程是否已经在安全序列中,若存在就判断下一个进程;

若当前进程 row 还没有处在安全序列,就开始深度优先搜索:将当前进程 row 已经分配到的系统资源数目加到当前可用的资源数目中,即 Allocation 矩阵中第 row 行的所有数目加到 Available 向量中;然后将当前进程 row 添加到安全序列中(此安全序列是一个栈);递归调用搜索的函数,向下一个进程开始搜索;

在搜索的过程中需要判断所有的进程是否已经添加到安全序列中,即查看安全序列(栈)的大小是否等于当前系统的进程数目;若达到了就将安全序列输出并且开始回溯;此判断应该放在深度优先搜索函数的前面,用来作为递归出口;

然后将最近加入到安全序列中的进程从安全队列中删除,即从栈中弹出一个元素,记为 row;然后修改此进程row未加在安全序列中的状态;将此进程row收回的资源数目归还,即从 Available 向量中减去 Allocation 矩阵中第 row 行的数目;然后向下一个进程搜索。

核心代码

/**

* allocation: Allocation 每个进程已经分配的资源数目的矩阵

* need: Need 每个进程还需的资源数目的矩阵

* available: Available 剩余资源数的矩阵

* row: 表示从哪个进程开始向下扫描

* queue: 已加入安全序列的进程(栈性质)

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
银行家算法=-- - 1. 安全状态: 在某时刻系统中所有进程可以排列一个安全序列:{P1,P2,`````Pn},刚称此时,系统是安全的. 所谓安全序列{P1,P2,`````Pn}是指对于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(在推算过程中,所有进程均可以完成),则表示(分配过后)系统是安全的,否则系统是不安全的.
银行家算法是一种用于避免死锁的算法,它需要根据当前系统资源的分配情况和进程的请情况,判断是否存在安全序列,以保证系统的正常运行。下面是一个简单的银行家算法的实现代码: ```c #include <stdio.h> #define MAX_PROCESS 10 #define MAX_RESOURCE 10 int available[MAX_RESOURCE]; int max[MAX_PROCESS][MAX_RESOURCE]; int allocation[MAX_PROCESS][MAX_RESOURCE]; int need[MAX_PROCESS][MAX_RESOURCE]; int work[MAX_RESOURCE]; int finish[MAX_PROCESS]; void init() { int i, j; printf("请输入系统资源数目:"); int resource_num; scanf("%d", &resource_num); printf("请输入每种资源的数量:"); for (i = 0; i < resource_num; i++) { scanf("%d", &available[i]); } printf("请输入进程数目:"); int process_num; scanf("%d", &process_num); printf("请输入每个进程最大需要的各种资源数量:"); for (i = 0; i < process_num; i++) { for (j = 0; j < resource_num; j++) { scanf("%d", &max[i][j]); } } printf("请输入每个进程已经得到的各种资源数量:"); for (i = 0; i < process_num; i++) { for (j = 0; j < resource_num; j++) { scanf("%d", &allocation[i][j]); need[i][j] = max[i][j] - allocation[i][j]; } finish[i] = 0; } } int safety() { int i, j, k; int resource_num = sizeof(available) / sizeof(int); int process_num = sizeof(finish) / sizeof(int); for (i = 0; i < resource_num; i++) { work[i] = available[i]; } int count = 0; while (count < process_num) { int found = 0; for (i = 0; i < process_num; i++) { if (!finish[i]) { int flag = 1; for (j = 0; j < resource_num; j++) { if (need[i][j] > work[j]) { flag = 0; break; } } if (flag) { finish[i] = 1; found = 1; count++; for (k = 0; k < resource_num; k++) { work[k] += allocation[i][k]; } } } } if (!found) { return 0; } } return 1; } int main() { init(); if (safety()) { printf("存在安全序列!\n"); } else { printf("不存在安全序列!\n"); } return 0; } ``` 该代码首先通过 `init` 函数获取系统资源和进程的信息,然后通过 `safety` 函数判断是否存在安全序列。在 `safety` 函数中,使用 `work` 数组记录当前可用的系统资源,使用 `finish` 数组记录已经完成的进程,使用计数器 `count` 记录已经完成的进程数目。通过对每个进程的资源需和当前可用资源进行比较,如果存在进程可以完成,则将该进程标记为已完成,并将其所需资源释放给系统。如果所有进程都不能完成,则说明不存在安全序列
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值