java动态分区分配算法_Java实现操作系统中四种动态内存分配算法：BF+NF+WF+FF

最新推荐文章于 2022-12-07 14:23:42 发布
最新推荐文章于 2022-12-07 14:23:42 发布
阅读量1.6k 收藏 11
点赞数 3
文章标签： java动态分区分配算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42515225/article/details/114353840
版权

1 概述

本文是利用Java实现操作系统中的四种动态内存分配方式 ，分别是：

BF

NF

WF

FF

分两部分，第一部分是介绍四种分配方式的概念以及例子，第二部分是代码实现以及讲解。

2 四种分配方式

2.1 概念

操作系统中有一个动态分区分配的概念，内存在初始化的时候不会划分区域，而是在进程装入的时候，根据所要装入的进程动态地对内存空间进行划分，以提高内存空间的利用率，降低碎片的大小，主要的方法有一下四种：

首次适应算法(First Fit)：从空闲分区链首开始查找，直到找到一个满足其大小要求的空闲分区为止

循环首次适应算法(Next Fit)：从上次找到的空闲分区的下一个开始查找

最佳适应算法(Best Fit)：把空闲分区按大小递增的方式形成分区链，找到第一个能满足要求的空闲分区就进行分配

最坏适应算法(Worst Fit)：与最佳适应算法相反，把空闲分区按大小递减的方式形成分区链，找到第一个能满足要求的空闲分区就进行分配

2.2 例子

假设现在有100MB的内存空间，某一时刻先后分配了20MB、4MB、10MB内存，示意图如下：

b0feb4b9342d2b7d20263ad1548c905f.png

现在需要再分配5MB内存。

若采用FF，因为FF是直接按顺序分配内存，从低地址开始搜索空闲分区，因此便会从第一块空闲分区分配5MB(地址0-5)，示意图：

ba6f5f50db1c609836b345f13230d0cc.png

若采用NF，NF与FF类似，只不过NF是从上一次找到的空闲分区的下一块开始查找，因为上一次分配的是10MB，因此会从最后一块空闲分区(地址80-100)分配内存：

dde8a54212ec9768092fa98cdb29c2e3.png

若采用BF，BF是遍历所有空闲分区并找到一个能满足要求的最小分区，也就会找到一个比5MB大的空闲分区，且该空闲分区是所有空闲分区中最小的，也就是地址为64-70的空闲分区：

fad224f2583867120489e6ec24ef17ff.png

若采用WF，WF与BF相反，总是从最大的空闲分区开始分配，因此会从地址为30-60的空闲分区进行分配：

fee9fd84f4c53c1c34cb455bee146d9b.png

3 代码实现

3.1 总览

代码分成了四个类：

13ff6b97659f8fd9b8b205b66c2482c1.png

Main：测试

Print：输出打印

Table：表示每一个分区

TableList：对分区进行控制，包括初始化，分配，回收等

3.2 Main

Main是测试类，代码如下：

public class Main {

private final static TableList list = new TableList(64);

public static void main(String[] args) {

list.useWF();

// list.useBF();

// list.useNF();

// list.useFF();

list.allocate(10);

list.allocate(20);

list.free(10);

list.show();

list.allocate(8);

list.show();

list.allocate(13);

list.allocate(1);

list.show();

list.free(1);

list.allocate(9);

list.free(13);

list.show();

list.allocate(18);

list.show();

list.allocate(3);

list.allocate(4);

list.free(20);

list.free(8);

list.show();

list.allocate(8);

list.free(9);

list.show();

list.clear();

list.show();

}

}

通过TableList对内存进行分配以及释放，初始化分配64MB大小内存，切换分配算法时使用前四行的其中一行即可。

3.3 Table

Table类表示每一个分区，无论是空闲的还是已分配的，成员变量有四个，分别是：

起始地址

大小

是否空闲(只有两种状态，空闲或分配)

是否是上一次分配(NF专用)

代码如下：

@AllArgsConstructor

public class Table {

@Getter

@Setter

private int address;

@Setter

@Getter

private int size;

private boolean free;

@Getter

@Setter

private boolean lastAllocated;

public static Table freeTable(int address,int size)

{

return new Table(address,size,true,false);

}

public static Table allocatedTable(int address,int size)

{

return new Table(address,size,false,false);

}

public boolean isFree()

{

return free;

}

public boolean isAllocated()

{

return !isFree();

}

public void setFree()

{

free = true;

}

}

只有一些Getter和Setter，为了方便提供了一个创建空闲分区或已分配分区的静态方法，指定起始地址和大小即可。

3.4 TableList

TableList是整个算法的核心类，成员变量如下：

private final List

private final int totalSize;

private boolean ff = false;

private boolean nf = false;

private boolean bf = false;

private boolean wf = false;

private boolean first = true;

private final static Print print = new Print();

list就是所有的空闲分区与已分配分区组成的数组，totalSize是总大小，接着是四个控制算法的布尔变量，first表示是否是第一次分配内存，因为第一次的话四种算法都是固定的从地址为0处开始分配。

接下来就是内存分配算法以及释放算法。

3.4.1 FF

if (ff)

{

for (int i = 0; i < list.size(); i++) {

Table table = list.get(i);

if(table.isFree() && table.getSize() >= size)

{

int address = table.getAddress();

Table allocated = Table.allocatedTable(address,size);

table.setAddress(address+size);

table.setSize(table.getSize()-size);

list.add(i,allocated);

return;

}

}

}

FF的实现还是比较简单的，直接遍历列表，如果是空闲分区并满足大小要求，直接进行分配，修改空闲分区的起始地址和大小并插入一个新的已分配分区到列表中即可。

3.4.2 NF

else if (nf)

{

int lastNFIndex = findLastAllocated();

int i = lastNFIndex;

do

{

if(i == list.size())

i = 0;

Table table = list.get(i);

if(table.isFree() && table.getSize() >= size)

{

int address = table.getAddress();

Table allocated = Table.allocatedTable(address,size);

table.setAddress(address+size);

table.setSize(table.getSize()-size);

list.get(lastNFIndex).setLastAllocated(false);

table.setLastAllocated(true);

list.add(i,allocated);

return;

}

++i;

}

while (i != lastNFIndex);

}

NF的话需要提前记录上一次分配的位置，通过Table中的lastAllocated确定上一次分配的位置，找到后从该位置开始遍历列表，注意需要进行绕回处理，因为到末尾位置后有可能还没有能满足的空闲分区，此时需要将下标绕回到0并再次遍历直到到达上一次分配的位置。

3.4.3 BF+WF

由于BF与WF都需要遍历所有的空闲分区，只是前者是选择最小满足要求的，后者是选择最大满足要求的，因此两者的实现差别在于一个判断大小的符号，代码如下：

else

{

int i;

int target = -1;

for (i = 0; i < list.size(); i++) {

Table table = list.get(i);

if(table.isFree())

{

if(table.getSize() >= size)

{

if(target == -1)

target = i;

else

{

if(bf)

{

if(list.get(target).getSize() > table.getSize())

target = i;

}

else

{

if(list.get(target).getSize() < table.getSize())

target = i;

}

}

}

}

}

if(target != -1)

{

Table table = list.get(target);

int address = table.getAddress();

table.setAddress(address+size);

table.setSize(table.getSize()-size);

list.add(target,Table.allocatedTable(address,size));

return;

}

}

首先遍历找到符合条件的空闲分区的下标，接着通过判断target，也就是目标空闲分区的下标，如果为-1表示没有找到符合条件的空闲分区，如果不为-1直接分配空间。

3.4.4 释放算法

释放算法的设计是比较复杂的，代码如下：

public void free(int size)

{

int index = 0;

while(index < list.size())

{

if(list.get(index).isAllocated() && list.get(index).getSize() == size)

break;

++index;

}

if(index >= list.size())

{

print.freeFailed(size);

return;

}

int address = list.get(index).getAddress();

if(index == 0)

{

list.get(0).setFree();

if(index+1 < list.size())

{

Table nextTable = list.get(index+1);

if(nextTable.isFree())

{

list.get(0).setSize(nextTable.getSize()+size);

list.remove(index+1);

}

}

}

else if(index == list.size()-1)

{

list.get(index).setFree();

Table lastTable = list.get(index-1);

if(lastTable.isFree())

{

lastTable.setSize(lastTable.getSize()+size);

list.remove(index);

}

}

else

{

Table before = list.get(index-1);

Table after = list.get(index+1);

if(before.isFree() && after.isFree())

{

before.setSize(before.getSize()+size+after.getSize());

list.remove(index+1);

list.remove(index);

}

else if(before.isFree() && after.isAllocated())

{

before.setSize(before.getSize()+size);

list.remove(index);

}

else if(before.isAllocated() && after.isFree())

{

after.setSize(after.getSize()+size);

after.setAddress(address);

list.remove(index);

}

else

{

list.get(index).setFree();

}

}

}

主要考虑了六种情况(黄色代表需要释放的空间，橙色是已分配的内存空间)：

fd02643fc123836785d86e04785f15f2.png

第一种情况就是需要释放首部的分区，此时需要修改后面空闲分区的起始地址和大小，并删除目标分区

第二种情况是释放尾部的分区，此时需要修改前面空闲分区的大小即可，无需修改起始地址，并删除目标分区

第三种情况是后面是已分配的分区，前面的空闲分区，需要修改前面空闲分区的大小，并删除目标分区

第四种情况是前面是已分配的分区，后面是空闲分区，需要修改后面的空闲分区的起始地址以及大小，并删除目标分区

第五种情况是前后都是已分配的分区，此时只需要修改目标分区的标志为空闲即可，无需额外操作

第六种情况是前后都是空闲分区，这种情况下需要进行连接操作，具体来说就是先修改前面空闲分区的大小，接着删除目标分区以及后面的空闲分区

下面回到代码，首先是判断第一种情况：

if(index == 0)

{

list.get(0).setFree();

if(index+1 < list.size())

{

Table nextTable = list.get(index+1);

if(nextTable.isFree())

{

list.get(0).setSize(nextTable.getSize()+size);

list.remove(index+1);

}

}

}

也就是需要释放首部的分区，通过setFree()设置标志位表示空闲状态，接着判断是否需要修改后面空闲分区的大小，因为有可能后面是一个已分配的分区而不是空闲分区。

else if(index == list.size()-1)

{

list.get(index).setFree();

Table lastTable = list.get(index-1);

if(lastTable.isFree())

{

lastTable.setSize(lastTable.getSize()+size);

list.remove(index);

}

}

这里是判断第二种情况，也就是释放尾部的分区，同样需要判断前一个分区是已分配的分区还是空闲的分区，是空闲分区的话修改大小并移除目标分区。

else

{

Table before = list.get(index-1);

Table after = list.get(index+1);

if(before.isFree() && after.isFree())

{

before.setSize(before.getSize()+size+after.getSize());

list.remove(index+1);

list.remove(index);

}

else if(before.isFree() && after.isAllocated())

{

before.setSize(before.getSize()+size);

list.remove(index);

}

else if(before.isAllocated() && after.isFree())

{

after.setSize(after.getSize()+size);

after.setAddress(address);

list.remove(index);

}

else

{

list.get(index).setFree();

}

}

接下来是最后四种情况的判断，首先获取前一个以及后一个分区，接着按上面算法的思路进行判断即可。

4 测试

以WF为例，默认大小64MB，测试顺序如下：

分配10MB

分配20MB

释放10MB

打印结果

分配8MB

打印结果

分配13MB

分配1MB

打印结果

释放1MB

分配9MB

释放13MB

打印结果

分配18MB

打印结果

分配3MB

分配4MB

释放20MB

释放8MB

打印结果

分配8MB

释放9MB

打印结果

清空

打印结果

输出：

Free : 0-10MB

Allocated : 10-30MB

Free : 30-64MB

----------------------------------------------------------------

Free : 0-10MB

Allocated : 10-30MB

Allocated : 30-38MB

Free : 38-64MB

----------------------------------------------------------------

Free : 0-10MB

Allocated : 10-30MB

Allocated : 30-38MB

Allocated : 38-51MB

Allocated : 51-52MB

Free : 52-64MB

----------------------------------------------------------------

Free : 0-10MB

Allocated : 10-30MB

Allocated : 30-38MB

Free : 38-51MB

Allocated : 51-60MB

Free : 60-64MB

----------------------------------------------------------------

Do nothing.

Allocated failed, out of memory

Free : 0-10MB

Allocated : 10-30MB

Allocated : 30-38MB

Free : 38-51MB

Allocated : 51-60MB

Free : 60-64MB

----------------------------------------------------------------

Allocated : 0-4MB

Free : 4-38MB

Allocated : 38-41MB

Free : 41-51MB

Allocated : 51-60MB

Free : 60-64MB

----------------------------------------------------------------

Allocated : 0-4MB

Allocated : 4-12MB

Free : 12-38MB

Allocated : 38-41MB

Free : 41-64MB

----------------------------------------------------------------

Free : 0-64MB

----------------------------------------------------------------

读者可以自行画图验证。

5 源码

如果觉得文章好看，欢迎点赞。

同时欢迎关注微信公众号：氷泠之路。

ebe708739090e88a25ec43acae9dd054.gif

爱笑的眼睛洁
关注
用java实现动态分区
Sunshine
12-12 2917
用java实现动态分区问题，运用链表的知识，实现分配和回收，这个问题在回收过程中需要考虑8种情况，并按照相应的情况决定是否对空闲分区进行合并。 package 动态分区; public class Area { private int number; private String name; private int startaddress; private i
操作系统java实验六动态分区分配算法实现
iiiiiaaaaa337的博客
05-30 1136
package 实验六; import java.util.*; //从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业， public class FF { private static class Node { int id; // 作业id,为-1代表空闲分区;大于0代表已分配 int start; // 初始地址 int size; // 大小 public String toString(.
操作系统 动态分区分配 Java 实现
qq_45755106的博客
11-14 1527
操作系统 动态分区分配 Java 实现 1. 分配算法原理 操作系统 动态分区分配 2. 代码实现 package dynamicMemoAlloc; class Block{ private int id; // id == -1 表示空闲分区 private int begin; private int end; private int size; private Block next; public Block(int id, int begin,
操作系统实验 模拟存储器分配算法 (java)
weixin_62278826的博客
12-07 1106
用高级语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：作业1申请130KB。作业2申请60KB。作业3申请100KB。作业2释放60KB。作业4申请200KB。作业3释放100KB。作业1释放130KB。
操作系统实验和课设，java实现动态内存分配和回收，FF,NF,WF,BF
01-09
操作系统实验和课设，java实现动态内存分配和回收，实现算法FF,NF,WF,BF,有swing界面
FF_NF_BF_WF.rar_FF_ NF_BF_Java FF BF WF算法_bf wf算法_bf存储分配_ff_wf_b
09-19
在`FF_NF_BF_WF.rar`这个压缩包中，包含的可能是一个Java程序，实现了上述四种算法的模拟。通过运行这个程序，我们可以观察和比较它们在不同场景下的性能表现，理解它们的优缺点，并为实际操作系统设计提供参考。 ...
操作系统_实验_课程设计_动态分区分配_四种内存分配方式_代码&报告 FF、NF、WF、BF
12-10
本实验主要探讨了四种不同的动态分区分配策略：首次适应（First Fit, FF）、最佳适应（Best Fit, NF）、最差适应（Worst Fit, WF）以及最佳 Fit with Buddy（BF）。这些方法在实际操作系统的内存管理中扮演着关键...
操作系统课程设计-模拟实现多种内存动态分区分配算法
最新发布
10-01
动态分区分配算法有四种：首次适应算法(first fit，FF)、循环首次适应算法(next fit，NF)、最佳适应算法(best fit，BF)、最坏适应算法(worst fit，WF)。 要求：1、输入若干个内存需求（至少5个）到空闲分区链表（或...
分区分配与回收算法模拟实现
04-21
在本项目中，我们将实现四种不同的分配算法：首次适应算法(First Fit, FF)、循环首次适应算法(Next Fit, NF)、最佳适应算法(Best Fit, BF)和最坏适应算法(Worst Fit, WF)，并通过空闲链表的方式实现这些算法。...
操作系统动态分区分配算法java版定义.pdf
11-05
总之，这个实验通过Java实现了操作系统中动态分区分配的四种经典算法，提供了对内存管理机制的直观理解和实践经验。通过编写和调试这样的程序，学生可以更好地掌握这些算法的工作原理和实际应用。
实现动态分区分配模拟实验 JAVA
12-01
操作系统实验：实现动态分区分配模拟实验 JAVA实现，源代码
java实现内存动态分配
05-09
每运行一个java程序会产生一个java进程，每个java进程可能包含一个或者多个线程，每一个Java进程对应唯一一个JVM实例，每一个JVM实例唯一对应一个堆，每一个线程有一个自己私有的栈。进程所创建的所有类的实例（也就是对象）或数组（指的是数组的本身，不是引用）都放在堆中,并由该进程所有的线程共享。Java中分配堆内存是自动初始化的，即为一个对象分配内存的时候，会初始化这个对象中变量。虽然Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在栈中分配,也就是说在建立一个对象时在堆和栈中都分配内存，在堆中分配的内存实际存放这个被创建的对象的本身，而在栈中分配的内存只是存放指向这个堆对象的引用而已。局部变量 new 出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC回收。 java实现内存动态分配目录 一．实验原理 二．实验流程图 三．实验代码 四．实验结果
Java模拟操作系统中动态分区
孟祥月的专栏
11-22 2774
【作者：孟祥月  博客：http://blog.csdn.net/mengxiangyue】 下面的代码模拟的是操作系统动态分区的过程。这里简单的介绍一下动态分区，在pc中有一定大小的内存，开始的时候这些内存都没有使用。我们可以在这个内存上去分配内存给对应的进程，这里的进程名字和进程的所需要的内存大小是我们自己输入的。我们模拟的是在内存的开始寻找能够分配给该进程的空闲区域分配给该进程，如果分
首次适应算法 动态分区分配java_Java实现内存分配算法 FF(首次适应算法) BF(最佳适应算法)...
weixin_32945435的博客
02-13 593
1 packagexqy.been;23 importjava.util.ArrayList;4 importjava.util.Collections;5 importjava.util.Comparator;67 public classMemory {8 private intsize;9 private intfragment;10 privateString al...
操作系统之动态分区分配算法 （java）
zzsaixuexi的博客
11-26 4008
（实验目的、实验原理、实验步骤、内容、程序代码、实验数据、结论等） 1.实验目的 详细了解系统之中是如何存储进程的。 通过实验加强对基于顺序搜索的动态分区分配算法的理解和掌握。 加深理解有关存储结构的概念。 主存的分配和回收的实现与主存储器的管理方式有关的，通过本实验帮助学生理解在可变分区管理方式下应怎样实现主存空间的分配和回收。 2.实验要求 代码实现四种算法 撰写课程设计报告 报告要有设计、实现、测试等过程。 3.实验过程描述 原理（思路） 态分区分配是根据进程的实际需要，动态地
分代收集算法详解
许佳佳的博客
09-24 2590
此篇文章较多借鉴《深入理解Java虚拟机》 前提概要这篇文章算是对前一篇文章的一个补充，主要地讲一下涉及知识点较多的分代收集算法。如果对Java垃圾回收算法还不是很了解的读者可以先看上一篇文章：Java垃圾回收算法。分代收集概念根据对象的存活周期不同将内存划分为新生代和老年代，存活周期短的为新生代，存活周期长的为老年代。这样就可以根据每块内存的特点采用最适当的收集算法。 新生代的中每次垃圾收集中
面试官：讲一下Java的分区收集算法？
qingyangcc123的博客
06-11 346
Java的分区收集算法也是面试中的考察点，很多人对此不清楚。下面详细的介绍一下 分代收集概念 根据对象的存活周期不同将内存划分为新生代和老年代，存活周期短的为新生代，存活周期长的为老年代。这样就可以根据每块内存的特点采用最适当的收集算法。 新生代的中每次垃圾收集中会发现有大批对象死区，只有少量存活，那就选用复制算法，只需要付出少量存活对象的复制成本就可以完成收集。 老年代中因为对象的存活率高，没有额外的控件对它进行分配担保，就必须使用“标记-清扫”或者“标记-整理”算法来进行回收。 Java语言中一个显著的
操作系统-（动态分区算法java实现）
lin1151211427的博客
05-07 2437
动态分区存储管理 实验目的：熟悉并掌握动态分区分配的各种算法。 熟悉并掌握动态分区中分区回收的各种情况，并能够实现分区合并。 实验内容：用高级语言模拟实现动态分区存储管理，要求： 1、 分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。 2、 分区的初始化——可以由用户输入初始分区的大小。（初始化后只有一个空闲分区，起始地址为0，大小是用户输入的大小） 3、 分区的动态分配过程：由用户输入作业号和作业的大小，实现分区过程。 4、 分区的回收：用户输
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值