此次课程设计的主要内容是模拟操作系统实现资源分配。要求编写和调试一个系统动态分配资
源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效地防止和避免死锁的发生。
具体算法可考虑用银行家算法实现资源分配。要求如下：
(1)设计一个5个并发进程共享3类不同资源的系统(设计的银行家算法可以超过5个进程及
3类资源)。
(2)设计的银行家算法，实现资源分配的详细过程，应具有显示或打印每个进程依次申请的资
源数以及分配资源的情况。算法要求系统判断是否安全状态，若有多个安全路径，算法要求能全部
打印所有安全路径。
(3)确定一组进程依次申请资源数的序列，运行银行家算法判断是否满足该资源申请，观察运
行结果，如书上例子所示。
(4)原始数据的初次化。原始数据要求：最好是以文件读入方式或随机数自动产生，键盘输入
或程序中用数组初始化方式（不建议使用后两种算法）。
使用c语言实现，原始数据随机生成。
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3
int available[MAX_RESOURCES]; // 可用资源数量
int max_claim[MAX_PROCESSES][MAX_RESOURCES]; // 进程对各资源的最大需求
int allocation[MAX_PROCESSES][MAX_RESOURCES]; // 已分配给进程的资源数量
int need[MAX_PROCESSES][MAX_RESOURCES]; // 进程对各资源的尚需数量
bool finish[MAX_PROCESSES]; // 进程是否完成
void generate_random_data()
{
// 设置随机数种子为当前时间
srand(time(NULL));
// 生成可用资源数量
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] = rand() % 10 + 1; // 随机数范围在1到10之间
}
// 生成每个进程的最大需求和已分配数量
for (int i = 0; i < MAX_PROCESSES; i++)
{
for (int j = 0; j < MAX_RESOURCES; j++)
{
max_claim[i][j] = rand() % (available[j] + 1); // 随机数范围在0到available[j]之间
allocation[i][j] = rand() % (max_claim[i][j] + 1); // 随机数范围在0到max_claim[i][j]之间
need[i][j] = max_claim[i][j] - allocation[i][j];
}
}
}
bool is_safe_state()
{
int work[MAX_RESOURCES];
bool finish[MAX_PROCESSES];
int safe_sequence[MAX_PROCESSES];
int count = 0;
// 初始化工作向量
for (int i = 0; i < MAX_RESOURCES; i++)
{
work[i] = available[i];
}
// 初始化进程完成状态
for (int i = 0; i < MAX_PROCESSES; i++)
{
finish[i] = false;
}
// 执行安全性算法
while (count < MAX_PROCESSES)
{
bool found = false;
// 遍历所有进程
for (int i = 0; i < MAX_PROCESSES; i++)
{
// 检查未完成的进程
if (!finish[i])
{
bool can_execute = true;
// 检查进程对每个资源的需求是否小于等于可用资源
for (int j = 0; j < MAX_RESOURCES; j++)
{
if (need[i][j] > work[j])
{
can_execute = false;
break;
}
}
// 找到可以执行的进程
if (can_execute)
{
// 分配资源给进程
for (int j = 0; j < MAX_RESOURCES; j++)
{
work[j] += allocation[i][j];
}
// 标记进程为已完成
finish[i] = true;
// 将进程添加到安全序列
safe_sequence[count] = i;
count++;
found = true;
}
}
}
// 未找到可执行进程，系统处于不安全状态
if (!found)
{
return false;
}
}
// 打印安全序列
printf("安全序列: ");
for (int i = 0; i < MAX_PROCESSES - 1; i++)
{
printf("P%d -> ", safe_sequence[i]);
}
printf("P%d\n", safe_sequence[MAX_PROCESSES - 1]);
return true;
}
bool request_resources(int process_id, int request[])
{
// 检查请求是否超过进程的最大需求
for (int i = 0; i < MAX_RESOURCES; i++)
{
if (request[i] > need[process_id][i])
{
printf("错误：进程 P%d 的资源请求超过了其最大需求\n", process_id);
return false;
}
}
// 检查请求是否超过可用资源
for (int i = 0; i < MAX_RESOURCES; i++)
{
if (request[i] > available[i])
{
printf("错误：进程 P%d 的资源请求超过了可用资源\n", process_id);
return false;
}
}
// 假设分配资源给进程
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] -= request[i];
allocation[process_id][i] += request[i];
need[process_id][i] -= request[i];
}
// 检查分配后的系统是否处于安全状态
if (!is_safe_state())
{
// 回滚分配
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] += request[i];
allocation[process_id][i] -= request[i];
need[process_id][i] += request[i];
}
printf("警告：进程 P%d 的资源请求会导致系统进入不安全状态\n", process_id);
return false;
}
printf("成功：进程 P%d 的资源请求已被满足\n", process_id);
return true;
}
void print_state()
{
printf("系统当前状态:\n");
printf("可用资源: ");
for (int i = 0; i < MAX_RESOURCES; i++)
{
printf("%d ", available[i]);
}
printf("\n");
printf("进程 Allocation Need Work\n");
for (int i = 0; i < MAX_PROCESSES; i++)
{
printf("P%d ", i);
for (int j = 0; j < MAX_RESOURCES; j++)
{
printf("%d ", allocation[i][j]);
}
printf(" ");
for (int j = 0; j < MAX_RESOURCES; j++)
{
printf("%d ", need[i][j]);
}
printf(" ");
for (int j = 0; j < MAX_RESOURCES; j++)
{
printf("%d ", max_claim[i][j]);
}
printf("\n");
}
}
int main()
{
// 生成随机数据
generate_random_data();
// 打印初始状态
printf("初始状态:\n");
print_state();
// 运行资源分配模拟
while (true)
{
int process_id;
int request[MAX_RESOURCES];
printf("请输入要申请资源的进程ID（0-%d），输入-1退出：", MAX_PROCESSES - 1);
scanf("%d", &process_id);
if (process_id == -1)
break;
if (process_id < 0 || process_id >= MAX_PROCESSES)
{
printf("错误：无效的进程ID\n");
continue;
}
printf("请输入进程P%d申请的资源数：", process_id);
for (int i = 0; i < MAX_RESOURCES; i++)
{
scanf("%d", &request[i]);
}
// 执行资源请求
request_resources(process_id, request);
// 打印当前状态
printf("当前状态:\n");
print_state();
}
return 0;
}
--------------------------------------------------------------------------------------------------------------
上一版有误，以下是修正后的代码
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#define MAX_PROCESSES 5
#define MAX_RESOURCES 3
int available[MAX_RESOURCES]; // 可用资源数量
int max_claim[MAX_PROCESSES][MAX_RESOURCES]; // 进程对各资源的最大需求
int allocation[MAX_PROCESSES][MAX_RESOURCES]; // 已分配给进程的资源数量
int need[MAX_PROCESSES][MAX_RESOURCES]; // 进程对各资源的尚需数量
bool finish[MAX_PROCESSES];
int safe_sequence[MAX_PROCESSES]; // 安全队列
int num_safe_processes = 0; // 安全队列中的进程数量
void print_state()
{
printf("当前系统状态:\n");
printf("可用资源: ");
for (int i = 0; i < MAX_RESOURCES; i++)
{
printf("%d ", available[i]);
}
printf("\n");
printf("进程 Allocation Need Max Claim\n");
for (int i = 0; i < MAX_PROCESSES; i++)
{
printf("P%d ", i);
for (int j = 0; j < MAX_RESOURCES; j++)
{
printf("%d ", allocation[i][j]);
}
printf(" ");
for (int j = 0; j < MAX_RESOURCES; j++)
{
printf("%d ", need[i][j]);
}
printf(" ");
for (int j = 0; j < MAX_RESOURCES; j++)
{
printf("%d ", max_claim[i][j]);
}
if (finish[i]) printf(" (已执行)");
printf("\n");
}
}
void generate_random_data()
{
srand(time(NULL));
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] = rand() % 10 + 1;
}
for (int i = 0; i < MAX_PROCESSES; i++)
{
for (int j = 0; j < MAX_RESOURCES; j++)
{
max_claim[i][j] = rand() % (available[j] + 1);
allocation[i][j] = rand() % (max_claim[i][j] + 1);
need[i][j] = max_claim[i][j] - allocation[i][j];
}
}
for (int i = 0; i < MAX_PROCESSES; i++) {
finish[i]= false;
safe_sequence[i]=-1;
}
}
void print_safe_sequence(int work[],bool can_finish[],int safe[],int n){
if (n ==MAX_PROCESSES){
printf("安全序列: ");
for (int i = 0; i < MAX_PROCESSES; i++) {
printf("P%d ", safe[i]);
}
printf("\n");
}
for (int i = 0; i < MAX_PROCESSES; i++)
{
if (!can_finish[i])
{
bool can_allocate = true;
for (int j = 0; j < MAX_RESOURCES; j++)
{
if (need[i][j] > work[j])
{
can_allocate = false;
break;
}
}
if (can_allocate)
{
for (int j = 0; j < MAX_RESOURCES; j++)
{
work[j] += allocation[i][j];
}
can_finish[i] = true;
safe[n] = i;
print_safe_sequence(work,can_finish,safe,n+1);
// 回溯
for (int j = 0; j < MAX_RESOURCES; j++) {
work[j] -= allocation[i][j];
}
can_finish[i]= false;
}
}
}
}
bool is_safe_state()
{
int work[MAX_RESOURCES];
bool can_finish[MAX_PROCESSES];
int safe[MAX_PROCESSES];
int n = num_safe_processes;
for (int i = 0; i < MAX_PROCESSES; i++) {
safe[i]=safe_sequence[i];
}
for (int i = 0; i < MAX_RESOURCES; i++)
{
work[i] = available[i];
}
for (int i = 0; i < MAX_PROCESSES; i++)
{
can_finish[i] = finish[i];
}
print_safe_sequence(work,can_finish,safe,n);
for (int i = 0; i < MAX_PROCESSES; i++) {
if(safe[i]==-1) return false;
}
return true;
}
void request_resources(int process_id, int request[])
{
for (int i = 0; i < MAX_RESOURCES; i++)
{
if (request[i] > need[process_id][i])
{
printf("错误：进程P%d请求的资源超过了最大需求\n", process_id);
return;
}
}
// 尝试分配资源
bool can_allocate = true;
for (int i = 0; i < MAX_RESOURCES; i++)
{
if (request[i] >available[i])
{
printf("错误：进程P%d请求的资源超过了现有资源数\n", process_id);
return;
}
}
if (can_allocate)
{
// 分配资源
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] -= request[i];
allocation[process_id][i] += request[i];
need[process_id][i] -= request[i];
}
if(need[process_id][0]==0&&need[process_id][1]==0&&need[process_id][2]==0)
{
finish[process_id]=true;
safe_sequence[num_safe_processes]=process_id;
num_safe_processes++;
}
// 检查系统是否处于安全状态
if (!is_safe_state())
{
printf("分配资源成功，但系统处于不安全状态\n");
}
else
printf("分配成功，系统安全\n");
if(need[process_id][0]==0&&need[process_id][1]==0&&need[process_id][2]==0)
{
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] += allocation[process_id][i];
allocation[process_id][i]=0;
}
printf("进程已满足，释放P%d的资源",process_id);
}
}
}
void release_resources(int process_id, int release[])
{
for (int i = 0; i < MAX_RESOURCES; i++)
{
if (release[i] > allocation[process_id][i])
{
printf("错误：进程P%d释放的资源超过了已分配的数量\n", process_id);
return;
}
}
// 释放资源
for (int i = 0; i < MAX_RESOURCES; i++)
{
available[i] += release[i];
allocation[process_id][i] -= release[i];
need[process_id][i] += release[i];
}
printf("进程P%d释放资源成功\n", process_id);
}
int main()
{
generate_random_data();
print_state();
int process_id;
int request[MAX_RESOURCES];
int release[MAX_RESOURCES];
while (true)
{
printf("\n请输入要操作的进程号（0-%d），输入-1退出：", MAX_PROCESSES - 1);
scanf("%d", &process_id);
if (process_id == -1)
{
break;
}
printf("请输入进程P%d请求的资源数量：", process_id);
for (int i = 0; i < MAX_RESOURCES; i++)
{
scanf("%d", &request[i]);
}
request_resources(process_id, request);
print_state();
}
return 0;
}
扫一扫
717
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
