操作系统-用Java实现动态内存分配（首次适应算法，循环首次适应算法，最佳适应算法，最坏适应算法FF,NF,BF,WF）

入口

package neicunfenpei;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Memory my = new Memory();
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("请输入要分配内存还是要释放内存");
System.out.println("1 分配内存 2 释放内存");
int n =sc.nextInt();
switch(n) {
case 1:{
System.out.println("请输入要分配的内存大小");
int size = sc.nextInt();
my.allocation(size);
my.showZones();
break;
}
case 2:{
System.out.println("输入想要释放内存的分区号");
int id = sc.nextInt();
my.collection(id);
break;
}
}
}
}
}

主体

package neicunfenpei;
import java.util.LinkedList;
import java.util.Scanner;
public class Memory{
//内存大小
private int size;
//最小剩余分区大小
private static final int MIN_SIZE = 2;
//内存分区
private LinkedList<Zone> zones;
//上次分配的空闲区位置
private int pointer;
// 分区节点类
class Zone{
// 分区大小
private int size;
//分区始址
private int head;
//空闲状态
private boolean isFree;
public Zone(int head, int size) {
this.head = head;
this.size = size;
this.isFree = true;
}
}
//默认内存大小512K
public Memory(){
this.size = 512;
this.pointer = 0;
this.zones = new LinkedList<>();
zones.add(new Zone(0, size));
}
public Memory(int size) {
this.size = size;
this.pointer = 0;
this.zones = new LinkedList<>();
zones.add(new Zone(0, size));
}
//内存分配
public void allocation(int size){
System.out.println("1.FirstFit 2.NextFit 3.BestFit 4.WorstFit");
System.out.print("请选择分配算法:");
Scanner in = new Scanner(System.in);
int xuanze = in.nextInt();
switch (xuanze){
case 1:
fristFit(size);break;
case 2:
nextFit(size);break;
case 3:
bestFit(size);break;
case 4:
worstFit(size);break;
default:
System.out.println("请重新选择!");
}
}
// FF
private void fristFit(int size){
//遍历分区链表
for (pointer = 0; pointer < zones.size(); pointer++){
Zone tmp = zones.get(pointer);
//找到可用分区（空闲且大小足够）
if (tmp.isFree && (tmp.size > size)){
doAllocation(size, pointer, tmp);
return;
}
}
//遍历结束后未找到可用分区, 则内存分配失败
System.out.println("无可用内存空间!");
}
//NF
private void nextFit(int size){
Zone tmp = zones.get(pointer);
if (tmp.isFree && (tmp.size > size)){
doAllocation(size, pointer, tmp);
return;
}
int len = zones.size();
int i = (pointer + 1) % len;
for (; i != pointer; i = (i+1) % len){
tmp = zones.get(i);
if (tmp.isFree && (tmp.size > size)){
doAllocation(size, i, tmp);
return;
}
}
//全遍历后如果未分配则失败
System.out.println("无可用内存空间!");
}
//BF
private void bestFit(int size){
int flag = -1;
int min = this.size;
for (pointer = 0; pointer < zones.size(); pointer++){
Zone tmp = zones.get(pointer);
if (tmp.isFree && (tmp.size > size)){
if (min > tmp.size - size){
min = tmp.size - size;
flag = pointer;
}
}
}
if (flag == -1){
System.out.println("无可用内存空间!");
}else {
doAllocation(size, flag, zones.get(flag));
}
}
//WF
private void worstFit(int size){
int flag = -1;
int max = 0;
for (pointer = 0; pointer < zones.size(); pointer++){
Zone tmp = zones.get(pointer);
if (tmp.isFree && (tmp.size > size)){
if (max < tmp.size - size){
max = tmp.size - size;
flag = pointer;
}
}
}
if (flag == -1){
System.out.println("无可用内存空间!");
}else {
doAllocation(size, flag, zones.get(flag));
}
}
//开始分配
private void doAllocation(int size, int location, Zone tmp) {
//要是剩的比最小分区MIN_SIZE小，则把剩下那点给前一个进程
if (tmp.size - size <= MIN_SIZE){
tmp.isFree = false;
} else {
Zone split = new Zone(tmp.head + size, tmp.size - size);
zones.add(location + 1, split);
tmp.size = size;
tmp.isFree = false;
}
System.out.println("成功分配 " + size + "KB 内存!");
}
//内存回收
public void collection(int id){
if (id >= zones.size()){
System.out.println("无此分区编号!");
return;
}
Zone tmp = zones.get(id);
int size = tmp.size;
if (tmp.isFree) {
System.out.println("指定分区未被分配, 无需回收");
return;
}
//如果回收的分区后一个是空闲就和后一个合并
if (id < zones.size() - 1 && zones.get(id + 1).isFree){
Zone next = zones.get(id + 1);
tmp.size += next.size;
zones.remove(next);
}
//回收的分区要是前一个是空闲就和前分区合并
if (id > 0 && zones.get(id - 1).isFree){
Zone previous = zones.get(id - 1);
previous.size += tmp.size;
zones.remove(id);
id--;
}
zones.get(id).isFree = true;
System.out.println("内存回收成功!, 本次回收了 " + size + "KB 空间!");
}
//展示分区状况
public void showZones(){
System.out.println("分区编号t
分区始址t
分区大小t 空闲状态t");
for (int i = 0; i < zones.size(); i++){
Zone tmp = zones.get(i);
System.out.println(i + "tt" + tmp.head + "tt" +
tmp.size + "
t" + tmp.isFree);
}
}
}

最后

以上就是欢呼银耳汤为你收集整理的操作系统-用Java实现动态内存分配（首次适应算法，循环首次适应算法，最佳适应算法，最坏适应算法FF,NF,BF,WF）的全部内容，希望文章能够帮你解决操作系统-用Java实现动态内存分配（首次适应算法，循环首次适应算法，最佳适应算法，最坏适应算法FF,NF,BF,WF）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。