实验三、动态分区方式的模拟
在文章末尾有Java实现的完整代码，最主要的还是能够理解各种动态分配算法的核心
实验环境：
Linux 平台
实验时间：
6 小时
实验目的：
1.掌握动态分区分配方式使用的数据结构和分配算法（首先/最佳/最坏适应分配算法）。
2.进一步加深对内存动态分区分配管理方式及其实现过程的理解。
实验目标：
编写 C 语言或者Java语言程序模拟实现首次/最佳/最坏适应算法的内存块分配和回收，要求每次分配 和回收后显示出空闲分区和已分配分区的情况。假设初始状态下，可用的内存空间为 640KB。
实验方法：
该实验主要目的是模拟实现动态分区管理方式中内存的分配与回收，而设计的分配与回 收算法涉及到三种：首次适应算法、最佳适应算法和最差适应算法。根据动态分区分配的原理，主要需要建立两个数据结构：空闲分区表和已分配分区表，都需要包含分区的起始地址、 长度等信息。当有新作业请求装入主存时，须查找空闲分区表，从中找出一个合适的空闲分 区分配给作业。按照作业需要的内存大小，来装入作业，划分下的部分仍然为空闲分区，登 记在空闲分区表中，作业占用的分区登记到已分配分区表。作业执行完毕，应回收作业占用的分区，具体操作为：删除已分配分区表中的相关项；修改空闲分区表，根据情况增加或合并空闲分区
1、构建内存分区的数据结构
2、编写分配内存的方法
3、编写FF、BF和WF算法
FF代码
BF代码
WF代码
4、编写内存回收算法
5、模拟动态分配的运行情况
实验结果：
结果部分自己运行即可：
FF算法分配内存
回收内存
WF算法分配内存
回收内存
BF算法分配内存
完整代码
package 考试_1927406019;
import java.awt.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class MemoryLoc {
public static class Memory {
char job_name; //作业名称
int start_address; //起始地址
int alloc_size; //分区大小
int state; //状态 1表示已经分配，0表示未分配
}
public static void recovery(ArrayList<Memory> memories) {
System.out.println("Input the name of the task you want to recovery: ");
char name;
Scanner input = new Scanner(System.in);
name = input.next().charAt(0);
int size = memories.size();
if (size == 1) {
memories.get(0).job_name = ' ';
memories.get(0).state = 0;
System.out.println("Recover Successfully ");
return;
}
boolean flag = false;
for (int i = 0; i < memories.size(); i++) {
if (i == 0 && memories.get(i).job_name == name) {
//第一个就是要回收的分区
flag = true;
if (memories.get(i + 1).state == 0) {
memories.get(i).job_name = ' ';
memories.get(i).state = 0;
memories.get(i).alloc_size += memories.get(i + 1).alloc_size;
for (int j = i + 1; j < memories.size() - 1; j++) {
memories.get(j).job_name = memories.get(j + 1).job_name;
memories.get(j).start_address = memories.get(j + 1).start_address;
memories.get(j).alloc_size = memories.get(j + 1).alloc_size;
memories.get(j).state = memories.get(j + 1).state;
}
memories.remove(memories.size() - 1); //删除最后一个元素
}
else {
memories.get(i).job_name = ' ';
memories.get(i).state = 0;
}
}
else if (i == (memories.size() - 1) && memories.get(i).job_name == name) {
flag = true;
if (memories.get(i - 1).state == 0) {
memories.get(i - 1).alloc_size += memories.get(i).alloc_size;
memories.get(i - 1).job_name = ' ';
memories.remove(memories.size() - 1);
}
else {
memories.get(i).job_name = ' ';
memories.get(i).state = 0;
}
}
else if (memories.get(i).job_name == name) {
flag = true;
if (memories.get(i - 1).state == 0 && memories.get(i + 1).state == 0) {
memories.get(i - 1).alloc_size += (memories.get(i).alloc_size + memories.get(i + 1).alloc_size);
memories.get(i - 1).job_name = ' ';
for (int j = i; j < memories.size() - 1; j++) {
//移动两次，这是第一次
memories.get(j).job_name = memories.get(j + 1).job_name;
memories.get(j).start_address = memories.get(j + 1).start_address;
memories.get(j).alloc_size = memories.get(j + 1).alloc_size;
memories.get(j).state = memories.get(j + 1).state;
}
memories.remove(memories.size() - 1);
for (int j = i; j < memories.size() - 1; j++) {
// 这是第二次移动
memories.get(j).job_name = memories.get(j + 1).job_name;
memories.get(j).start_address = memories.get(j + 1).start_address;
memories.get(j).alloc_size = memories.get(j + 1).alloc_size;
memories.get(j).state = memories.get(j + 1).state;
}
memories.remove(memories.size() - 1);
}
else if (memories.get(i - 1).state == 0) {
memories.get(i - 1).alloc_size += memories.get(i).alloc_size;
memories.get(i - 1).job_name = ' ';
for (int j = i; j < memories.size() - 1; j++) {
// 这是第二次移动
memories.get(j).job_name = memories.get(j + 1).job_name;
memories.get(j).start_address = memories.get(j + 1).start_address;
memories.get(j).alloc_size = memories.get(j + 1).alloc_size;
memories.get(j).state = memories.get(j + 1).state;
}
memories.remove(memories.size() - 1);
}
else if (memories.get(i + 1).state == 0) {
memories.get(i).alloc_size += memories.get(i + 1).alloc_size;
memories.get(i).job_name = ' ';
memories.get(i).state = 0;
for (int j = i + 1; j < memories.size() - 1; j++) {
// 这是第二次移动
memories.get(j).job_name = memories.get(j + 1).job_name;
memories.get(j).start_address = memories.get(j + 1).start_address;
memories.get(j).alloc_size = memories.get(j + 1).alloc_size;
memories.get(j).state = memories.get(j + 1).state;
}
memories.remove(memories.size() - 1);
}
else {
memories.get(i).job_name = ' ';
memories.get(i).state = 0;
}
}
if (flag) {
System.out.println("Recover Successfully ");
return;
}
}
System.out.println("Recover Failure, can't find the task");
}
public static Memory preNode() {
Memory node = new Memory();
System.out.println("The name of your task(one character): ");
Scanner input = new Scanner(System.in);
String str = input.next();
char c = str.charAt(0);
node.job_name = c;
System.out.println("The size of your task");
int u = input.nextInt();
node.alloc_size = u;
return node;
}
public static void AllocateMemory(ArrayList<Memory> memories, Memory node) {
int flag = 0; // 分配成功为1 失败为0
for (int i = 0; i < memories.size(); i++) {
if (memories.get(i).state == 0) {
//空闲链表进行分配内存
if (memories.get(i).alloc_size >= node.alloc_size) {
if (memories.get(i).alloc_size - node.alloc_size <= 2) {
memories.get(i).state = 1; //将该分区从空闲链表中移除
memories.get(i).job_name = node.job_name; //名字也分配给它
}
else {
node.start_address = memories.get(i).start_address;
memories.get(i).start_address += node.alloc_size;
memories.get(i).alloc_size -= node.alloc_size;
node.state = 1;
memories.add(i, node);
}
flag = 1;
break;
}
}
}
if (flag == 1) {
System.out.println("Alloc Successfully!!");
}
else {
System.out.println("Alloc Failure!!");
}
}
public static void FF(ArrayList<Memory> memories, Memory node) {
//首次适配算法
//对分区按照分配地址排序
Collections.sort(memories, new Comparator<Memory>() {
@Override
public int compare(Memory o1, Memory o2) {
return o1.start_address - o2.start_address;
}
});
AllocateMemory(memories, node);
}
public static void WF(ArrayList<Memory> memories, Memory node) {
//最坏适应算法
Collections.sort(memories, new Comparator<Memory>() {
//和最佳适应法的区别在于排序
@Override
public int compare(Memory o1, Memory o2) {
return o2.alloc_size - o1.alloc_size;
}
});
AllocateMemory(memories, node);
Collections.sort(memories, new Comparator<Memory>() {
@Override
public int compare(Memory o1, Memory o2) {
return o1.start_address - o2.start_address;
}
});
}
public static void BF(ArrayList<Memory> memories, Memory node) {
//最佳适应算法
Collections.sort(memories, new Comparator<Memory>() {
//按照分区大小来排序
@Override
public int compare(Memory o1, Memory o2) {
return o1.alloc_size - o2.alloc_size;
}
});
AllocateMemory(memories, node);
Collections.sort(memories, new Comparator<Memory>() {
@Override
public int compare(Memory o1, Memory o2) {
return o1.start_address - o2.start_address;
}
});
}
public static void Menu() {
System.out.println();
System.out.println("==================================");
System.out.println("1. First-fit algorithm");
System.out.println("2. Best-fit algorithm");
System.out.println("3. Worst-fit algorithm");
System.out.println("4. Other number to exit the program");
System.out.println("==================================");
System.out.println("Please enter your choice: ");
}
public static void ShowMemory(ArrayList<Memory> memories) {
int count1 = 0;
int count2 = 0;
System.out.println("*************************** Unallocated Table ************************");
System.out.println("Number Start address End address Allocation size");
for (int i = 0; i < memories.size(); i++) {
Memory node = memories.get(i);
int state = node.state;
if (state == 0) {
count1++;
int start_address = node.start_address;
int alloc_size = node.alloc_size;
System.out.println("-----------------------------------------------------------------------------------");
String res = " " + count1 + " " + start_address + " " + (start_address + alloc_size - 1) + " " + alloc_size;
System.out.println(res);
System.out.println("-----------------------------------------------------------------------------------");
System.out.println();
}
}
System.out.println();
System.out.println();
System.out.println("*************************** Allocated Table ************************");
System.out.println("Number Task name Start address End address Allocation size");
for (int i = 0; i < memories.size(); i++) {
Memory node = memories.get(i);
int state = node.state;
if (state == 1) {
count2++;
char name = node.job_name;
int start_address = node.start_address;
int alloc_size = node.alloc_size;
System.out.println("-----------------------------------------------------------------------------------");
String res = " " + count2 + " " + name + " " + start_address + " " + (start_address + alloc_size - 1) + " " + alloc_size;
System.out.println(res);
System.out.println("-----------------------------------------------------------------------------------");
System.out.println();
}
}
}
public static void Choose(ArrayList<Memory> memories, int num) {
while (true) {
System.out.println("Please enter a/r/other character to allocate or recover the memory or to exit the program");
Scanner input = new Scanner(System.in);
char c = input.next().charAt(0);
if (c == 'a') {
Memory node = preNode();
if (num == 1) {
FF(memories, node);
}
else if (num == 2) {
BF(memories, node);
}
else {
WF(memories, node);
}
}
else if (c == 'r') {
recovery(memories);
}
else {
return;
}
ShowMemory(memories);
}
}
public static void main(String[] args) {
Memory head = new Memory();
head.job_name = ' ';
head.start_address = 0;
head.alloc_size = 640;
head.state = 0;
ArrayList<Memory> memories = new ArrayList<>();
memories.add(head);
while (true) {
int choice_number = 0;
Menu();
Scanner input = new Scanner(System.in);
choice_number = input.nextInt();
if (choice_number == 1) {
System.out.println("You choice the First-fit algorithm");
Choose(memories, 1);
}
else if (choice_number == 2) {
System.out.println("You choice the Best-fit algorithm");
Choose(memories, 2);
}
else if (choice_number == 3) {
System.out.println("You choice the Worst-fit algorithm");
Choose(memories, 3);
}
else {
break;
}
}
}
}