DDD操作系统实验（七）最终版

最新推荐文章于 2023-05-04 16:24:30 发布
最新推荐文章于 2023-05-04 16:24:30 发布
阅读量382 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jojohacker/article/details/124872608
版权

银行家算法

实验目的

  1. 理解死锁产生原因，避免死锁与预防死锁的方法
  2. 能够编写代码实现银行家算法以避免死锁。

实验内容

学习课本上关于银行家算法的流程描述，明确每个步骤的含义，完成下面习题（如下英文所示）。要求：

  1. 以书上或者老师PPT的例子为例，可以input.txt文件形式，也可以手动输入的形式，依次读入进程数，资源数和实例数，分配矩阵，最大需求矩阵和可用资源向量。注意下面标黄色的英语。

  2. 输出可能的安全序列。

  3. 鼓励同学自己实现，实在有困难，可参考附件代码。

    Write a multithreaded program that implements the banker’s algorithm. Create n threads that request and release resources from the bank. The banker will grant the request only if it leaves the system in a safe state. You should write this program using Pthreads.

    It is important that access to shared data is safe from concurrent access. Such data can be safely accessed using mutex locks, which are available in Pthread API.

实验准备

实验前请学习课本关于银行家算法的描述，明确求取安全序列的步骤。

实验要求

实现平台：ubuntu
完成程序后，填写本报告，并贴出结果、给出分析。实验报告与代码一起打包上传。
另外，如果你使用了参考代码，则需要通过在代码旁添加注释等多种方式体现你对代码的理解。（其实不用）

实验结果与分析

实验结果

与课本给出的实例对照，验证是否正确实现
在这里插入图片描述
在这里插入图片描述

结果分析

  • 首先由用户输入数据（这里用input.txt代替），分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION，并计算出需求矩阵
  • 在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。
  • 对于进程提出的请求REQUEST，如果小于NEED,则再判断是否小于AVALIABLE，再进行修改 AVALIABLE=AVALIABLE-REQUEST，ALLOCATION=REQUEST，NEED=NEED-REQUEST，否则任意一步均会出错

附上测试文件与代码

input.txt

5 3
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2
7 5 3
3 2 2
9 0 2
2 2 2
4 3 3
3 3 2
1
1 0 2

ddd提供的残缺代码

#include <pthread.h>
#include <stdio.h>

/**********************************************************************************
银行家算法是用于避免死锁的，本次实验，我们要模拟出这样的一种有可能产生死锁的情形：
系统中目前有很多线程，每个线程都有自己的最大资源需求、也已经分配了一些资源、还需要一些资源。
在这种情形下，系统容易发生死锁(原因思考下)。
然后，我们使用银行家算法来找到这些线程的一种可能的执行顺序，保证不会发生死锁。
************************************************************************************/


/*********************************************************************************
下列代码的各种矩阵是用手动输入的方式，建议同学们改成读文件的方式，这样方便调试
**********************************************************************************/


void *start_banker(void *param);

#define MAX_PRO 256   /* max process count */
#define MAX_RES 256	/* max resource type */

int available[MAX_RES];
int max[MAX_PRO][MAX_RES];
int allocation[MAX_PRO][MAX_RES];
int need[MAX_PRO][MAX_RES];
int request[MAX_RES];
int work[MAX_RES];
int finish[MAX_PRO];
int stop_flag = 0;
int m,n;
pthread_mutex_t mutex;
int proc_ids[MAX_PRO];

int main(int argc, char *argv[]){
	pthread_t tid[MAX_PRO];
	pthread_attr_t attr[MAX_PRO];

	int id;
	int i,j;
  //输入当前系统中有几个并发的线程
	printf ("please input the process count(<=%d).\n",MAX_PRO);
	scanf("%d", &n);
  //输入当前系统中有几种资源
	printf ("please input the resource type count(<=%d).\n",MAX_RES);
	scanf("%d", &m);
	
	if (m>256 || n>256 || m<0 || n<0)
	{
		printf ("input error\n");
		return -1;
	}
	//输入已经分配的资源矩阵
	printf ("please input allocation matrix\n");
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			scanf("%d", &allocation[i][j]);
			
	//输入最大资源需求矩阵
	printf ("please input max matrix\n");
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			scanf("%d", &max[i][j]);

  //输入当前系统中还可得的资源向量
	printf ("please input available vector\n");
	for (j=0;j<m;j++)
		scanf("%d", &available[j]);

	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			/****************** get the need matrix here ************************/	
      //在这里计算下need矩阵

  //当前某个线程又发出了新的请求，还记得上课讲的发出新请求的银行家算法吗？
  //输入是哪个线程，请求了多少资源
	printf ("please input the process No. that request new resources\n");
	scanf("%d", &id);

	printf ("please input the request vector\n");
	for (j=0;j<m;j++)
		scanf("%d", &request[j]);

	
	printf ("#########################################\n");
	printf ("Allocation Matrix\n");
	for (i=0;i<n;i++){
		printf ("P%d\t\t",i);
		for (j=0;j<m;j++)
			printf ("%d\t",allocation[i][j]); 
		printf ("\n");
	}

	printf ("Max Matrix\n");
	for (i=0;i<n;i++){
		printf ("P%d\t\t",i);
		for (j=0;j<m;j++)
			printf ("%d\t",max[i][j]); 
		printf ("\n");
	}

	printf ("Available Vector\n");
	for (j=0;j<m;j++)
		printf ("%d\t",available[j]);
	printf ("\n");

	printf ("with additional resouces requests\nP%d\t\t",id);
	for (j=0;j<m;j++)
		printf ("%d\t", request[j]);
	printf ("\n");

	for (j=0;j<m;j++){
		/************** a new request, available matrix should be modified **********************/
		//既然某个线程发出了新的请求，相应的available矩阵、allocation矩阵、need矩阵是不是都要修改？
	  //是不是直接修改它们就可以了？需要额外判断什么？
	  
		
		if (available[j]<0){
			printf ("unsafe!\n");
			return 0;
		}
		
		
		/************** a new request, allocation and need matrix should be modified ******************/
		
		
		
	}
	
  //n表示线程数目，一开始，每个线程都标记成未完成,finish[i] = 0;
	for (i=0;i<n;i++)
		finish[i] = 0;
	//m表示资源种类数目，例如有ABC三类资源，那么m=2
	//开始时，把available赋值给work。
	for (j=0;j<m;j++)
		work[j] = available[j];
   
  //pay attention to the thread mutual exclusion
	printf ("start...\n");
	for (i=0;i<n;i++){
		proc_ids[i] = i;
		/******************** init and creat threads here, which will implement start_banker with parameter "process id" *********/
		//我们开始创建n个线程，想想怎么创建线程？第4章我们是不是实践过了？需要哪几个函数？
		//创建出来的线程就去执行start_banker
		
		
	}
	sleep(1);
	for (i=0;i<n;i++){
		if (finish[i]==0){//最后，只要发现有一个线程的finish=0，就说明没找到机会给该线程分配资源，系统就是不安全的，有可能死锁
			printf ("unsafe!!\n");
			break;
		}
	}
	if (i==n)
		printf ("safe!!\n");
	stop_flag = 1;
	printf ("Finish...\n");
	sleep(1);
	for (i=0;i<n;i++)
		/******************** use XX function here to wait the threads to finish **********************/
		//既然创建出来线程，那我们就要等待线程结束，想想用什么函数等待线程结束？
		
		
		
	return 0;
}

void *start_banker(void *param){
	int j;
	int id = *(int *)param; //process id
	
	while (!stop_flag && !finish[id]) {
		for (j=0;j<m;j++){
			if (need[id][j]> ?? /************* fill the condition to break ***********/) //对于id这个线程，它需要的某资源数目怎么样，就不需要继续执行了,这个线程现在肯定不能执行，need>work
				break;
		}
		//如果每个种类的资源都比较了一遍，发现都不break，那就说明对该线程的每个种类的资源need<work，那么这个线程可以执行。
		if (j==m) // need <= work{
			/******************** fill the code here to calculate work matrix and set finish value *******************/
			//这个线程执行完毕了，要修改哪个矩阵？work矩阵要修改，因为该线程执行完毕，会释放它的allocation
			//这个线程执行完毕了，还要记得把这个线程的finish标记下，说明它做完了，下次不要检查它了。
			//完成了上面的work和finish，我们再思考一下，如果现在有好几个线程都满足j==m这个条件，都能进到这个if语句里，那么他们是不是会一起修改work与finish呢？多个线程并发访问共享变量会有什么问题？怎么解决？
			
			
			
			
			printf ("P%d finished\n",id);
			
		}
	}
	pthread_exit(0);
}

填充完整的代码

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
/**********************************************************************************
银行家算法是用于避免死锁的，本次实验，我们要模拟出这样的一种有可能产生死锁的情形：
系统中目前有很多线程，每个线程都有自己的最大资源需求、也已经分配了一些资源、还需要一些资源。
在这种情形下，系统容易发生死锁(原因思考下)。
然后，我们使用银行家算法来找到这些线程的一种可能的执行顺序，保证不会发生死锁。
************************************************************************************/


/*********************************************************************************
下列代码的各种矩阵是用手动输入的方式，建议同学们改成读文件的方式，这样方便调试
**********************************************************************************/	
void *start_banker(void *param);
#define MAX_PRO 256   /* max process count */
#define MAX_RES 256	/* max resource type */

int available[MAX_RES];
int max[MAX_PRO][MAX_RES];
int allocation[MAX_PRO][MAX_RES];
int need[MAX_PRO][MAX_RES];
int request[MAX_RES];
int work[MAX_RES];
int finish[MAX_PRO];
int stop_flag = 0;
int m,n;
pthread_mutex_t mutex;
int proc_ids[MAX_PRO];

int main(int argc, char *argv[]){
	pthread_t tid[MAX_PRO];
	pthread_attr_t attr[MAX_PRO];

	int id;
	int i,j;

    FILE *input = fopen("input.txt","r");
    // scanf("%d", &n);
	// scanf("%d", &m);
    fscanf(input,"%d", &n);
    fscanf(input,"%d", &m);

	if (m>256 || n>256 || m<0 || n<0){
		printf ("input error\n");
		return -1;
	}
	printf ("please input allocation matrix\n");
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			// scanf("%d", &allocation[i][j]);
			fscanf(input,"%d",&allocation[i][j]);
		
	printf ("please input max matrix\n");
	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			// scanf("%d", &max[i][j]);
			fscanf(input,"%d",&max[i][j]);

	printf ("please input available vector\n");
	for (j=0;j<m;j++)
		// scanf("%d", &available[j]);
		fscanf(input,"%d",&available[j]);

	for (i=0;i<n;i++)
		for (j=0;j<m;j++)
			need[i][j] = max[i][j] - allocation[i][j];
			
	printf ("please input the process No. that request new resources\n");
	fscanf(input, "%d", &id);

	printf ("please input the request vector\n");
	for (j=0;j<m;j++)
		fscanf(input, "%d", &request[j]);

	
	printf ("#########################################\n");
	printf ("Allocation Matrix\n");
	for (i=0;i<n;i++){
		printf ("P%d\t\t",i);
		for (j=0;j<m;j++)
			printf ("%d\t",allocation[i][j]); 
		printf ("\n");
	}

	printf ("Max Matrix\n");
	for (i=0;i<n;i++){
		printf ("P%d\t\t",i);
		for (j=0;j<m;j++)
			printf ("%d\t",max[i][j]); 
		printf ("\n");
	}

	printf ("Available Vector\n");
	for (j=0;j<m;j++)
		printf ("%d\t",available[j]);
	printf ("\n");

	printf ("with additional resouces requests\nP%d\t\t",id);
	for (j=0;j<m;j++)
		printf ("%d\t", request[j]);
	printf ("\n");

	for (j=0;j<m;j++){
		if(request[j] > need[id][j]){
			printf("unsafe!\n");
			return 0;
		}
		available[j] -= request[j];
		if (available[j]<0)
		{
			printf ("unsafe!\n");
			return 0;
		}
		allocation[id][j] += request[j];
		need[id][j] -= request[j];
	}
	
	for (i=0;i<n;i++)
		finish[i] = 0;
	for (j=0;j<m;j++)
		work[j] = available[j];
		
	printf ("start...\n");
	for (i=0;i<n;i++){
		proc_ids[i] = i;
		pthread_attr_init(&attr[i]);
        pthread_create(&tid[i], &attr[i], start_banker, (void*)&proc_ids[i]);
	}
	sleep(1);
	for (i=0;i<n;i++){
		if (finish[i]==0)
		{
			printf ("unsafe!!\n");
			break;
		}
	}
	if (i==n)
		printf ("safe!!\n");
	stop_flag = 1;
	printf ("Finish...\n");
	sleep(1);
	for (i=0;i<n;i++)
		pthread_join(tid[i],NULL);
	return 0;
}

void *start_banker(void *param){
	int j;
	int id = *(int *)param; //process id
	
	while (!stop_flag && !finish[id]) {
		for (j=0;j<m;j++){
			if (need[id][j]> work[j])
				break;
		}
		if (j==m){ // need <= work{
			pthread_mutex_lock(&mutex);
            for (j=0;j<m;j++)
                work[j] += allocation[id][j];
            pthread_mutex_unlock(&mutex);
            finish[id] = 1;
			printf ("P%d finished\n",id);
		}
	}
	pthread_exit(0);
}
DDD的爱徒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统实验七 文件管理 附代码
10-27
1、使用pwd，cd，ls等命令浏览文件系统。 2、使用cat，cp，mv，head，tail，rm等命令查看你的文件。 3、使用ln命令进行文件的硬连接和符号连接。 4、使用find，grep命令进行文件查找和模式匹配。 5、使用chmod命令修改文件的权限。
DDD操作系统实验（四）
jojohacker的博客
04-08 825
线程实验目的实验内容2.1 线程基本操作2.2 跳高比赛实验准备 实验目的 掌握线程的创建、启动、运行等方法； 理解多线程，能够编写多线程类应用。 实验内容 2.1 线程基本操作 （1）阅读课本线程这一章Fig. 4.6关于线程创建的实例，然后完成课本上的习题4.9（见下面英文，我们要用ubuntu Pthread完成）。如果你确实无法完成4.9，请重复课本Fig. 4.6的实例（见下图，想省事直接拷贝对不对？可惜我贴心地贴了图嘿嘿嘿）。可以在代码中加入全局和局部变量，并观察结果，给出结果的同时要说明为
操作系统-第七次实验
qq_45755193的博客
12-22 1141
内存页面置换算法的设计 主存储器空间的分配和回收
究竟什么是DDD
阳光coding
04-21 4571
文章目录前言定义适用场景如何做?人的组织架构系统的架构设计 前言 DDD，网上太多解释了，但都大同小异，就是解释名词的，看的发晕，我这里给出通俗的解释，助大家能理解究竟什么才是DDD。 定义 DDD，英文全称是Domain Driven Design，对应的中文含义是领域驱动设计，指的是针对特定领域进行定制化的设计。 DDD是指导思想，不是具体的实操技术，这里有一个重点需要注意，不是每个系统设计都可以使用DDD，DDD解决的复杂问题。 适用场景 那DDD究竟适用于什么场景，从以下几种判断： 1、系统组
操作系统实验2 银行家算法（QT+C++）
weixin_51685674的博客
05-04 1212
一、目的：熟悉银行家算法，加深死锁有关概念的理解。二、内容：编制银行家算法通用程序，并检测思考题中所给状态的安全性。三、要求：(1) 下列状态是否安全？(三个进程共享12个同类资源)进程 已分配资源数 最大需求数1 1 4 (状态a)1 1 42 4 6 (状态b)(2) 考虑下列系统状态分配矩阵 最大需求矩阵 可用资源矩阵。
DDD 实践 申请审核系统.zip
03-13
在IT行业中，领域驱动设计（Domain-Driven Design，简称DDD）是一种软件开发方法，它强调以业务领域为中心来构建复杂的软件系统。DDD实践是通过深入理解业务领域，将复杂的业务逻辑转化为可维护、可扩展的代码结构。...
树莓派操作系统镜像-32位
最新发布
03-12
树莓派操作系统镜像-32位
DDD 实践－消息系统.zip
03-13
在IT行业中，领域驱动设计（Domain-Driven Design，简称DDD）是一种软件开发方法，它强调以业务领域为中心来构建复杂的软件系统。DDD的核心思想是通过深入理解业务领域，将复杂的业务逻辑转化为清晰的模型，从而提高...
ddd.rar_C 语言系统
09-14
"ddd.rar_C语言系统"这个资源可能是一个包含C语言源代码的项目，专注于讲解如何利用C语言进行操作系统级别的编程，涉及到的核心概念主要是进程管理，包括进程的创建、撤销、唤醒和激活。 首先，我们要理解操作系统...
ddd.zip_网上系统_订餐
09-21
【ddd.zip_网上系统_订餐】是一款基于C#编程语言开发的网上订餐系统，旨在提供一个结构清晰、操作简便的在线餐饮预订平台。这个系统涵盖了从用户界面设计、功能实现到后台管理的全套解决方案，旨在提升订餐效率，...
银行家算法
生如蚁，美如神
09-06 2375
引言我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。 为保证资金的安全,银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客; (2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在
操作系统实验报告 lab7
4ct10n
06-12 6860
练习0填写已有实验 练习1 理解内核级信号量的实现和基于内核级信号量的哲学家就餐问题 0x0 哲学家问题 0x1 信号量介绍 0x2 P操作V操作实现 0x3 代码分析 0x4 信号量性质 练习2 完成内核级条件变量和基于内核级条件变量的哲学家就餐问题 0x1 管程机制 0x2 数据结构 0x3 组成函数 实验截图练习0:填写已有实验使用meld的软件进行对比即可 这里把需要填充的文件罗列如下
DDD究竟是什么
热门推荐
白夜行
04-10 3万+
领域驱动设计架构
一文清晰讲明白DDD（领域驱动设计）的知识点
唐欢
09-22 5364
DDD（领域驱动设计）是一种处理高度复杂领域的设计思想，是一种架构设计方法论，是一种设计模式。以高内聚低耦合为目的，把一个复杂的软件应用系统中各个部分进行一个很好的拆解和封装，对软件系统进行模块化的一种思想。DDD不仅可以用于微服务设计，还可以很好地应用于企业中台的设计，也适用于传统的单体应用。
你真的需要防腐层吗？DDD 系统间的7种关系梳理与实践
燃烧杯的博客
02-14 820
当提到系统间交互的时候，人们都会想到大名鼎鼎的防腐层，用来防止其他系统的模型变更对本系统造成影响。但是在实践这个模式的过程中，我们常常会遇到问题。此时我们也应该考虑下其他的系统交互方式。
银行家算法（c语言/多线程/Linux环境）
weixin_51454889的博客
11-07 929
【代码】银行家算法（c语言/多线程/Linux环境）
领域驱动设计——DDD领域驱动设计基础
庄小焱
09-03 594
如果你以往对 DDD 的了解并不深入，甚至是第一次接触，你一定会觉得 DDD 的术语非常多，且非常陌生，这些术语之间的关系都算是个“拦路虎”。搞懂这些之后呢，怎么应用它们，从何下手来设计领域模型等等这些问题又接踵而至。如果你对 DDD 有过研究，在学会怎么用之后，你可能还会反过来想：“我费了这么大劲儿去搞懂它，那它到底会让我的系统变成什么样呢？可以解决什么具体问题？是不是真有大家说得那么好？”。本博文就是讲解 DDD 的核心知识体系，具体包括：领域、子域、核心域、通用域、支撑域、限界上下文、实体、值对象、聚
浅析领域驱动设计（DDD）——复杂系统如何被简单设计
DingdaoOS的博客
09-14 712
在软件开发周期中，系统分析和设计是分开的，导致需求和成品非常容易出现偏差，两者相对独立，还会导致沟通困难，而DDD开发模式则打破了这种隔阂，在业务知识梳理的过程中，形成某个领域知识，根据领域知识来一步步驱动软件设计。
c语言银行家算法_C语言中的银行家算法
culing2941的博客
09-14 896
c语言银行家算法Here you will get program for banker’s algorithm in C. 在这里，您将获得C语言中银行家算法的程序。 The banker’s algorithm which is also known as avoidance algorithm is a deadlock detection algorithm. It was deve...
DDD入门指南：中文版领域驱动设计基础
领域驱动设计（Domain-Driven Design，简称DDD）是一种软件开发方法论，它强调以业务领域为中心来构建复杂的软件系统。这个方法的核心是通过深入理解业务领域，创建一个反映领域知识的模型，以此来指导软件的设计和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值