【操作系统】实验三：进程调度

实验三：进程调度（8学时）

实验内容：

利用C语言编程银行家算法程序，并打印实验结果。

实验要求：

设计有5个进程共享5个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析。

提交内容：

流程图

源程序

#include<stdio.h>
#define NUM_PROCESSES 5
//进程数
#define NUM_RESOURCES 5
//资源种类数


int available[NUM_RESOURCES];//系统可用资源
int max[NUM_PROCESSES][NUM_RESOURCES];//最大需求矩阵
int allocation[NUM_PROCESSES][NUM_RESOURCES];//分配矩阵
int need[NUM_PROCESSES][NUM_RESOURCES];//还需要多少资源的矩阵
// 初始化资源和进程的数据结构
void initialize() {
    // 初始化系统资源
    int a[]={8,6,7,6,5};
    for (int i = 0; i < NUM_RESOURCES; ++i) {
        available[i] =a[i];  // 初始化可用资源数量
    }

    // 初始化每个进程的最大需求、已分配资源和尚需资源
    int b[5][5]={
    {3,5,6,2,3},
    {2,4,5,5,2},
    {2,5,7,3,2},
    {1,2,3,4,5},
    {5,4,3,2,1}
    };
    for (int i = 0; i < NUM_PROCESSES; ++i) {
        for (int j = 0; j < NUM_RESOURCES; ++j) {
            max[i][j] = b[i][j];  // 初始化最大需求
            allocation[i][j] = 0;
            need[i][j] = max[i][j];
        }
    }
}



// 显示当前资源状态
void displayState() {
    printf("Available resources: ");
    for (int i = 0; i < NUM_RESOURCES; ++i) {
        printf("%d ", available[i]);
    }
    printf("\n");

    printf("Process\tMax\tAllocated\tNeed\n");
    for (int i = 0; i < NUM_PROCESSES; ++i) {
        printf("%d\t", i);
        for (int j = 0; j < NUM_RESOURCES; ++j) {
            printf("%d ", max[i][j]);
        }
        printf("\t");
        for (int j = 0; j < NUM_RESOURCES; ++j) {
            printf("%d ", allocation[i][j]);
        }
        printf("\t");
        for (int j = 0; j < NUM_RESOURCES; ++j) {
            printf("%d ", need[i][j]);
        }
        printf("\n");
    }
}
//检查是否needi每一位都小于work
int checksmall(int need[][5],int work[],int p){
	for(int i=0;i<5;i++)
	{
		if(need[p][i]>work[i])
		{
			return 0;
			break;
		}
	}
	return 1;
}

//检查是否满足两个条件
int checkrequ(int finish[],int work[])
{
	for (int i=0;i<NUM_PROCESSES;++i)
	{
		if (finish[i]==0&&checksmall(need,work,i))
		{
			return i;
		}
	}
	return -1;
}
// 检查系统是否处于安全状态
int checkSafety() {
    // TODO: 实现银行家算法检查系统是否处于安全状态的逻辑
    // 如果系统处于安全状态，返回1，否则返回0
    int work[NUM_RESOURCES];
    int finish[NUM_PROCESSES];
    for (int i=0;i<NUM_RESOURCES;++i){
    	work[i]=available[i];
    	
    }
    for (int i=0;i<NUM_PROCESSES;++i){
    	finish[i]=0;
    }
    int s=1;
    for(;checkrequ(finish,work)!=-1;)
    {
    	int t=checkrequ(finish,work);
    	for(int j=0;j<NUM_PROCESSES;j++)
    	{
    		work[j]+=allocation[t][j];
    		finish[t]=1;
    	}
    }
    for(int i=0;i<NUM_PROCESSES;++i)
    {
    	if(finish[i]==0) return 0;
    }
    return 1;
}
// 进程申请资源
void requestResources(int process, int request[]) {


    // 检查申请是否合法
    for (int i = 0; i < NUM_RESOURCES; ++i) {
        if (request[i] > need[process][i] || request[i] > available[i]) {
            printf("Invalid request from process %d\n", process);
            
            return;
        }
    }
    // 模拟试探分配资源
    for (int i = 0; i < NUM_RESOURCES; ++i) {
        available[i] -= request[i];
        allocation[process][i] += request[i];
        need[process][i] -= request[i];
    }

    // 检查安全性
    if (checkSafety()) {
        printf("Resource request from process %d granted\n", process);
        displayState();
    } else {
        printf("Resource request from process %d denied (unsafe state)\n", process);

        // 回滚分配
        for (int i = 0; i < NUM_RESOURCES; ++i) {
            available[i] += request[i];
            allocation[process][i] -= request[i];
            need[process][i] += request[i];
        }
    }

    
}


// 进程释放资源
void releaseResources(int process, int release[]) {
    

    // 检查释放是否合法
    for (int i = 0; i < NUM_RESOURCES; ++i) {
        if (release[i] > allocation[process][i]) {
            printf("Invalid release from process %d\n", process);
            
            return;
        }
    }

    // 释放资源
    for (int i = 0; i < NUM_RESOURCES; ++i) {
        available[i] += release[i];
        allocation[process][i] -= release[i];
        need[process][i] += release[i];
    }

    printf("Resources released by process %d\n", process);
    displayState();
}



int main() {
	initialize();
	printf("initial resources as follows:\n");
	displayState();
	int choice;
    while (1) {
        // 显示菜单
        printf("please choice:\n");
        printf("1. request resources\n");
        printf("2. release resources\n");
        printf("0. exit\n");
        
        // 获取用户输入
        printf("input your choice: ");
        scanf("%d", &choice);

        // 根据用户选择执行相应的事务
        switch (choice) {
            case 1:
            	int p;
            	int request[NUM_RESOURCES];
                printf("please choose your process number:\n");
                scanf("%d", &p);
                printf("please input your request:\n");
                for(int i=0;i<NUM_RESOURCES;i++)
                {
                	scanf("%d", &request[i]);
				}
				requestResources(p, request);
                break;
            case 2:
    			int t;
            	int release[NUM_RESOURCES];
                printf("please choose your process number:\n");
                scanf("%d", &t);
                printf("please input your release:\n");
                for(int i=0;i<NUM_RESOURCES;i++)
                {
                	scanf("%d", &release[i]);
				}
				releaseResources(t, release);
                break;
            case 0:
                printf("system is closing down\n");
                return 0;  // 退出程序
            default:
                printf("invalid choice，please input again\n");
        }
    }

	return 0;
}

1. 显示初始状态，已赋给系统五个资源的最大可获得量和各进程的最大需求量

1. 选择分配资源

2.1正常分配

输入进程id 0 ,输入request=[1 0 0 0 0]

输出当前available，最大需求矩阵，分配矩阵和还需要的需求矩阵

继续分配资源

2.2异常分配资源

情况一：request超出need

情况二：request超出available

情况三：分配之后会进入不安全状态

改变max中（1，3）=7，会发生不安全状态

1. 选择释放资源

正常释放

释放异常

释放矩阵大于分配矩阵

1. 退出系统