动态分区分配算法模拟

最新推荐文章于 2023-12-02 15:59:39 发布
最新推荐文章于 2023-12-02 15:59:39 发布
阅读量1.2k 收藏 6
点赞数 5
文章标签： eclipse java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56851161/article/details/124487023
版权

//进程类封装

package pers.jintao.firstfit;

public class Progress {
    private int size;
    private String name;
    public Progress() {

    }
public Progress(int size,String name) {
        this.size=size;
        this.name=name;
    }
    public int getSize() {
         return this.size;
     }
    public void setSize(int size) {
          this.size=size;
     }
    public String getName() {
         return this.name;
     }
    public void setName(String name) {
          this.name=name;
     }
}

//空闲分区封装

package pers.jintao.firstfit;


public class Partition {
    private int size;
    private int residualSize;
    private String progress;
    
     public  Partition() {
        size=0;
        residualSize=0;
    }
     public  Partition(int size,int residualSize,String progress) {
            this.size=size;
            this.residualSize=residualSize;
            this.progress=progress;
        }
     public int getSize() {
         return this.size;
     }
     public int getResidualSize() {
         return this.residualSize;
     }
     public String getProgress() {
         return this.progress;
     }
     public void setSize(int size) {
         this.size=size;
     }
     public void setResidualSize(int residualSize) {
         this.residualSize=residualSize;
     }
     public void setProgress(String progress){
         this.progress+=progress;
     }
}

//首次适应算法

package pers.jintao.firstfit;

import java.util.ArrayList;
import java.util.Scanner;


public class FirstFit {
    public static void main(String[] args) {
        int partitionNum = 0;    //空闲分区数
        int progressNum =0;        //进程数
        boolean isEnd= false;    //初始化完成标志
        int flag=0;            //空闲分区操作标志
        int flag2=-1;        //进程操作标志
        ArrayList<Partition> arryPartition=new ArrayList<Partition>(); 
        ArrayList<Progress> arryProgress=new ArrayList<Progress>();
        Scanner sc=new Scanner(System.in);
        while(!isEnd){
            //空闲分区初始化
            if(flag==0) {
                System.out.print("输入空闲分区数");
                partitionNum=sc.nextInt();    
                flag++;
            }
            else if(flag2==-1){
                System.out.print("输入空闲分区"+flag+"大小");
                int size=sc.nextInt();
                Partition par=new Partition(size,size,"");            
                arryPartition.add(par);
                flag++;
                if(flag==partitionNum+1) {
                    flag2++;
                }
            }    
            //进程初始化
            else if(flag2==0) {
                System.out.print("输入进程数");
                progressNum=sc.nextInt();    
                flag2++;
            }
            else {
                System.out.print("输入进程"+flag2+"名称、大小");
                String name =sc.next();
                int size=sc.nextInt();
                Progress pro=new Progress(size,name);
                arryProgress.add(pro);
                flag2++;
                if(flag2==progressNum+1) {
                    isEnd=true;
                }
                
            }
        }
        sc.close();
        
        for(int i=0;i< progressNum;i++) {
            for(int j=0;j<partitionNum;) {
                if(arryProgress.get(i).getSize()<=arryPartition.get(j).getResidualSize()) {
                    arryPartition.get(j).setProgress(arryProgress.get(i).getName());
                    arryPartition.get(j).setResidualSize(arryPartition.get(j).getResidualSize()-arryProgress.get(i).getSize());
                    break;
                }
                j++;
                if(j==partitionNum) {
                    System.out.println(arryProgress.get(i).getName()+"无法分配");
                }
            }
        }
        System.out.println("分配后分区大小"+'\t'+"分配进程"+'\t');
        for(int i=0;i<arryPartition.size();i++) {
            System.out.println(""+arryPartition.get(i).getResidualSize()+'\t'+'\t'+arryPartition.get(i).getProgress()+'\t');
        }
    }
} 

       

//循环首次适应算法

package pers.jintao.nextfit;

import java.util.ArrayList;
import java.util.Scanner;

import pers.jintao.firstfit.Partition;
import pers.jintao.firstfit.Progress;

public class NextFit {
    public static void main(String[] args) {
        int partitionNum = 0;    //空闲分区数
        int progressNum =0;        //进程数
        boolean isEnd= false;    //初始化完成标志
        int flag=0;            //空闲分区操作标志
        int flag2=-1;        //进程操作标志
        ArrayList<Partition> arryPartition=new ArrayList<Partition>(); 
        ArrayList<Progress> arryProgress=new ArrayList<Progress>();
        Scanner sc=new Scanner(System.in);
        while(!isEnd){
            //空闲分区初始化
            if(flag==0) {
                System.out.print("输入空闲分区数");
                partitionNum=sc.nextInt();    
                flag++;
            }
            else if(flag2==-1){
                System.out.print("输入空闲分区"+flag+"大小");
                int size=sc.nextInt();
                Partition par=new Partition(size,size,"");            
                arryPartition.add(par);
                flag++;
                if(flag==partitionNum+1) {
                    flag2++;
                }
            }    
            //进程初始化
            else if(flag2==0) {
                System.out.print("输入进程数");
                progressNum=sc.nextInt();    
                flag2++;
            }
            else {
                System.out.print("输入进程"+flag2+"名称、大小");
                String name =sc.next();
                int size=sc.nextInt();
                Progress pro=new Progress(size,name);
                arryProgress.add(pro);
                flag2++;
                if(flag2==progressNum+1) {
                    isEnd=true;
                }
                
            }
        }
        sc.close();
        int progressFlag=0;
        for(int i=0;i< progressNum;i++) {
            for(int j=0;j<partitionNum;) {
                int num=progressFlag % partitionNum;
                if(arryProgress.get(i).getSize()<=arryPartition.get(num).getResidualSize()) {
                    arryPartition.get(num).setProgress(arryProgress.get(i).getName());
                    arryPartition.get(num).setResidualSize(arryPartition.get(num).getResidualSize()-arryProgress.get(i).getSize());
                    break;
                }
                progressFlag++;
                j++;
                if(j==partitionNum) {
                    System.out.println(arryProgress.get(i).getName()+"无法分配");
                }
            }
        }
        System.out.println("分配后分区大小"+'\t'+"分配进程"+'\t');
        for(int i=0;i<arryPartition.size();i++) {
            System.out.println(""+arryPartition.get(i).getResidualSize()+'\t'+'\t'+arryPartition.get(i).getProgress()+'\t');
        }
    }
}


//最佳适应算法

package pers.jintao.bestfit;

import java.util.ArrayList;
import java.util.Scanner;

import pers.jintao.firstfit.Partition;
import pers.jintao.firstfit.Progress;

public class BestFit {
    public static void main(String[] args) {
        int partitionNum = 0;    //空闲分区数
        int progressNum =0;        //进程数
        boolean isEnd= false;    //初始化完成标志
        int flag=0;            //空闲分区操作标志
        int flag2=-1;        //进程操作标志
        ArrayList<Partition> arryPartition=new ArrayList<Partition>(); 
        ArrayList<Progress> arryProgress=new ArrayList<Progress>();
        Scanner sc=new Scanner(System.in);
        while(!isEnd){
            //空闲分区初始化
            if(flag==0) {
                System.out.print("输入空闲分区数");
                partitionNum=sc.nextInt();    
                flag++;
            }
            else if(flag2==-1){
                System.out.print("输入空闲分区"+flag+"大小");
                int size=sc.nextInt();
                Partition par=new Partition(size,size,"");            
                arryPartition.add(par);
                flag++;
                if(flag==partitionNum+1) {
                    flag2++;
                }
            }    
            //进程初始化
            else if(flag2==0) {
                System.out.print("输入进程数");
                progressNum=sc.nextInt();    
                flag2++;
            }
            else {
                System.out.print("输入进程"+flag2+"名称、大小");
                String name =sc.next();
                int size=sc.nextInt();
                Progress pro=new Progress(size,name);
                arryProgress.add(pro);
                flag2++;
                if(flag2==progressNum+1) {
                    isEnd=true;
                }
                
            }
        }
        sc.close();
        
        for(int i=0;i< progressNum;i++) {
            int size=999;
            int num=0;
            for(int j=0;j<partitionNum;) {
                if(arryProgress.get(i).getSize()<=arryPartition.get(j).getResidualSize()&&size>arryPartition.get(j).getResidualSize()-arryProgress.get(i).getSize()) {
                    size=arryPartition.get(j).getResidualSize()-arryProgress.get(i).getSize();
                    num=j;
                }
                j++;
                if(j==partitionNum) {
                    if(size!=arryPartition.get(num).getResidualSize()-arryProgress.get(i).getSize()) {
                        System.out.println(arryProgress.get(i).getName()+"无法分配");
                    }
                    else {
                        arryPartition.get(num).setProgress(arryProgress.get(i).getName());
                        arryPartition.get(num).setResidualSize(size);
                    }
                }
            }
        }
        System.out.println("分配后分区大小"+'\t'+"分配进程"+'\t');
        for(int i=0;i<arryPartition.size();i++) {
            System.out.println(""+arryPartition.get(i).getResidualSize()+'\t'+'\t'+arryPartition.get(i).getProgress()+'\t');
        }
    }
}


//最坏适应算法

package pers.jintao.worstfit;

import java.util.ArrayList;
import java.util.Scanner;

import pers.jintao.firstfit.Partition;
import pers.jintao.firstfit.Progress;

public class WorstFit {
    public static void main(String[] args) {
        int partitionNum = 0;    //空闲分区数
        int progressNum =0;        //进程数
        boolean isEnd= false;    //初始化完成标志
        int flag=0;            //空闲分区操作标志
        int flag2=-1;        //进程操作标志
        ArrayList<Partition> arryPartition=new ArrayList<Partition>(); 
        ArrayList<Progress> arryProgress=new ArrayList<Progress>();
        Scanner sc=new Scanner(System.in);
        while(!isEnd){
            //空闲分区初始化
            if(flag==0) {
                System.out.print("输入空闲分区数");
                partitionNum=sc.nextInt();    
                flag++;
            }
            else if(flag2==-1){
                System.out.print("输入空闲分区"+flag+"大小");
                int size=sc.nextInt();
                Partition par=new Partition(size,size,"");            
                arryPartition.add(par);
                flag++;
                if(flag==partitionNum+1) {
                    flag2++;
                }
            }    
            //进程初始化
            else if(flag2==0) {
                System.out.print("输入进程数");
                progressNum=sc.nextInt();    
                flag2++;
            }
            else {
                System.out.print("输入进程"+flag2+"名称、大小");
                String name =sc.next();
                int size=sc.nextInt();
                Progress pro=new Progress(size,name);
                arryProgress.add(pro);
                flag2++;
                if(flag2==progressNum+1) {
                    isEnd=true;
                }
                
            }
        }
        sc.close();
        
        for(int i=0;i< progressNum;i++) {
            int size=0;
            int num=0;
            for(int j=0;j<partitionNum;) {
                if(arryProgress.get(i).getSize()<=arryPartition.get(j).getResidualSize()&&size<arryPartition.get(j).getResidualSize()-arryProgress.get(i).getSize()) {
                    size=arryPartition.get(j).getResidualSize()-arryProgress.get(i).getSize();
                    num=j;
                }
                j++;
                if(j==partitionNum) {
                    if(size!=arryPartition.get(num).getResidualSize()-arryProgress.get(i).getSize()) {
                        System.out.println(arryProgress.get(i).getName()+"无法分配");
                    }
                    else {
                        arryPartition.get(num).setProgress(arryProgress.get(i).getName());
                        arryPartition.get(num).setResidualSize(size);
                    }
                }
            }
        }
        System.out.println("分配后分区大小"+'\t'+"分配进程"+'\t');
        for(int i=0;i<arryPartition.size();i++) {
            System.out.println(""+arryPartition.get(i).getResidualSize()+'\t'+'\t'+arryPartition.get(i).getProgress()+'\t');
        }
    }
}

金 氵寿
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
操作系统之动态分区分配方式的模拟
gitfight
05-27 4349
目的和要求： 用C语言或C++语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端空间。 实验原理： 首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要球的空闲块就停止查找，并把它分配出去；如果该空闲...
动态分区分配算法(First Fit，Next Fit，Best Fit，Worst Fit)
热门推荐
木牛的博客
06-15 1万+
1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit）3.最佳适应算法（Best Fit）4.最坏适应算法（Worst Fit）1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit） 3.最佳适应算法（Best Fit） 4.最坏适应算法（Worst Fit） 1.首次适应算法（First Fit）2.循环首次适应算法（Next Fit）3.最佳适应算法（Best Fit）4.最坏适应算法（Worst Fit） (488条消息) 动态分
【操作系统】动态分区分配算法（附代码）
守夜人
05-20 4042
在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。：将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。：分配内存时不是从链首进行查找可以分配 内存的空闲分区，而是从上一次分配内存的空闲分区的下一个分区开始查找， 直到找到可以为该进程分配内存的空闲分区。：与最佳适应算法刚好相反，将空闲分区链的分区按照从大到小的顺序排序形成空闲分区链，每次查找时只要看第一个空闲分区是否满足即可。
内存动态分区分配算法
qq_46138755的博客
06-14 8460
所谓动态分区分配，就是指内存在初始时不会划分区域，而是会在进程装入时，根据所要装入的进程大小动态地对内存空间进行划分，以提高内存空间利用率，降低碎片的大小
动态分区分配策略（四种）
爱学习的JackYang的博客
10-19 6406
第一种：首次适应算法（Firstfit） 按空闲分区依地址递增次序链接，分配内存时按顺序查找,放入第一个匹配到的空闲分区，会造成内部碎片，有着较大的浪费 第二种：最佳适应算法（Bestfit） 将空闲分区按内存大小递增的顺序链接起来，分配内存时按照顺序放入第一个匹配的空闲分区。 第三种：最坏适应算法（Worstfit） 将空闲分区按容量递减的顺序链接起来，分配内存时放入第一个匹配的...
操作系统——实验五 动态分区分配算法的模拟
08-05
用C/C++实现一个完整的（可变）动态分区管理器，包括分配，回收，分区碎片整理等。希望同学们实现如下功能： 初始化功能：内存状态设置为初始状态。 分配功能：要求至少使用两种算法，用户可以选择使用。 回收...
操作系统 动态分区分配算法的模拟
09-17
操作系统中的动态分区分配是管理内存资源的重要方法，它允许系统根据需要动态地为进程分配内存空间。本模拟项目深入探讨了这一主题，并提供了运行正确的代码和设计报告，以帮助理解这些算法的工作原理。 动态分区...
循环首次适应的动态分区分配算法模拟.doc
05-11
在实验中，我们将构建一个模拟程序来模拟动态分区的分配和回收过程，这有助于直观地理解这些算法的工作原理，但需要注意，这个模拟并不实际操作硬件内存。 在【运行环境】部分，可能涉及的是运行这个模拟程序的...
动态分区分配算法-实验报告.docx
03-26
【动态分区分配算法】是操作系统中管理内存的一种方法，它主要应用于可变分区管理方式。在这样的系统中，内存被划分为多个不固定大小的分区，根据进程的需求动态分配。本实验报告关注的是动态分区分配中的【最先适应...
实验二 实现动态分区分配模拟程序
12-31
编写一个动态分区分配算法模拟程序，加深对动态分区存储管理方式及其实现过程的理解。 要求： 1.空闲分区通过空闲区链进行管理，在内存分配时，优先考虑低地址部分的空闲区。 2.分别采用首次适应算法、最佳适应算法...
动态分区分配方式模拟（c语言）
11-13
用C 语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOC（）和回收过程FREE（），其中空闲分区由空闲分区链来管理，进行分配时，系统优先使用空闲区底端空间。
操作系统动态分配模拟算法
12-02
1、编写并调试一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。 对分区的分配算法可以是下面三种算法之一： （1）首次适应算法 （2）循环首次适应算法 （3）最佳/差适应算法 文档包括四个算法实现的源代码和测试数据
计算机操作系统实验报告_动态分区分配方式的模拟
12-04
一是用C 语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOC（）和回收过程FREE（），其中空闲分区由空闲分区链来管理，进行分配时，系统优先使用空闲区底端空间。 二是假设初始状态下，可用内存空间为640KB。按照题目要求的作业顺序，以及各个作业分配和回收的内存空间。分别采用首次适应法和最佳适应法，对内存进行分配和回收，要求每次分配和回收后显示空闲内存分区链的情况。
动态分区分配四种算法
06-08
最佳适应算法 最坏适应算法 首次适应算法 循环首次适应算法 VC++通过
动态分区分配方式的模拟
01-31
用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程和回收过程。
操作系统 实验七 动态分区分配方式的模拟
weixin_46698891的博客
05-27 6408
实验七 动态分区分配方式的模拟 一、实验目的 了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。 二、实验环境 硬件环境：计算机一台，局域网环境； 软件环境： Windows或Linux操作系统， C语言编程环境。 三、实验内容 用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。 假设初始状态下
操作系统（动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法）
最新发布
weixin_62134940的博客
12-02 3907
设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n，空闲分区大小分别为P1, … ,Pn，在动态分区分配过程中需要分配的进程个数为m（m≤n），它们需要的分区大小分别为S1, … ,Sm，分别利用四种动态分区分配算法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况
动态分区分配存储管理方式的内存分配回收
振华OPPO的博客世界
03-26 8583
在动态分区分配存储管理方式的内存分配中，当有作业请求装入时，根据作业的需要内存空间的大小查询内存各个空闲区，从中找到一个大于或等于该作业大小的内存空闲区，然后按作业需求量划出一个分区装入该作业。作业执行完后，它占用的内存区被收回，称为空闲区，如果该空闲区的相邻分区也是空闲区，就要合并成为一个空闲区。
操作系统——动态分区分配模拟程序
Unintented的生涯路
05-31 3574
编写一个动态分区分配算法模拟程序，加深对动态分区存储管理方式及其实现过程的理解。要求：空闲分区通过空闲区链进行管理，在内存分配时，优先考虑低地址部分的空闲区。 分别采用首次适应算法、最佳适应算法和最坏适应算法模拟内存空间的动态分配与回收，每次分配和回收后显示出空闲区链的详细情况（说明：在申请不成功时，需要打印当前内存的占用情况信息）。 进程对内存空间的申请和释放可由用户自定义输入。 参考请求序列如...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值