实验要求：
1.本实验是模拟操作系统的主存分配，运用可变分区的存储管理算法设计主存分配和回收程序，并不实际启动装入作业。
2.采用最先适应法、最佳适应法、最坏适应法分配主存空间。
3. 当一个新作业要求装入主存时，必须查空闲区表，从中找出一个足够大的空闲区。若找到的空闲区大于作业需要量，这时应把它分成二部分，一部分为占用区，剩余部分又成为一个空闲区。
4.当一个作业撤离时，归还的区域如果与其他空闲区相邻，则应合并成一个较大的空闲区，登在空闲区表中。
5.运行所设计的程序，输出有关数据结构表项的变化和内存的当前状态。
代码：
1 /* 2 * author by Zephery Wen 3 * Date 2015.12.24 4 */ 5 import java.util.ArrayList; 6 import java.util.Scanner; 7 import java.util.Vector; 8 9 /*===============进程控制块===================*/ 10 class PCB { 11 String name; //记录控制块的名字 12 int memory; //记录存储块的容量 13 14 public String getName() { 15 return name; 16 } 17 18 public void setName(String name) { 19 this.name = name; 20 } 21 22 public int getMemory() { 23 return memory; 24 } 25 26 public void setMemory(int memory) { 27 this.memory = memory; 28 } 29 } 30 31 /* ==================存储块=============================== */ 32 class Memorys { 33 String name; 34 int size; 35 String station = "空闲"; 36 37 public String getName() { 38 return name; 39 } 40 41 public void setName(String name) { 42 this.name = name; 43 } 44 45 public int getSize() { 46 return size; 47 } 48 49 public void setSize(int size) { 50 this.size = size; 51 } 52 53 public String getStation() { 54 return station; 55 } 56 57 public void setStation(String station) { 58 this.station = station; 59 } 60 61 public String toString() { 62 String str = " " + this.name + " " + this.size + " " + this.station; 63 return str; 64 } 65 } 66 67 // ==================================================================== 68 class Methid { //存储块用的是List 69 public void swap(ArrayList<Memorys> list) { //swap方法排序 70 System.out.println("将存储块大小进行排序之后："); 71 for (int i = 0; i < list.size() - 1; i++) { //冒泡排序 72 for (int j = i; j < list.size(); j++) { 73 if (list.get(i).size > list.get(j).size) { 74 Object obj = list.get(i); 75 list.set(i, list.get(j)); 76 list.set(j, (Memorys) obj); 77 } 78 } 79 } 80 } 81 82 public void print(ArrayList<Memorys> list) { //输出 83 System.out.println(" 存储块名 存储大小 存储状态"); 84 for (int i = 0; i < list.size(); i++) { 85 System.out.println(list.get(i)); 86 } 87 } 88 } 89 90 // ================================================================= 91 class Access { 92 Scanner input = new Scanner(System.in); 93 Methid methid = new Methid(); 94 95 public void mainMethid(String str, Vector<PCB> pcbs, ArrayList<Memorys> list) { 96 while (true) { 97 System.out.println("请输入你要操作的步骤:"); 98 System.out.print(" 1:运行进程"); 99 System.out.print(" 2:结束进程"); 100 System.out.println(" 3:结束当前算法"); 101 System.out.print("请输入："); 102 int p = input.nextInt(); 103 if (p == 1) { /*----------运行进程运行进程运行进程-------------------*/ 104 System.out.println("请输入当前要运行的进程名"); 105 String name = input.next(); 106 for (int i = 0; i < pcbs.size(); i++) { 107 if (name.equals(pcbs.get(i).name)) { //输入要运行的进程名和第i个PCB的名字相同 108 /*将空闲区按其在存储空间中的起始地址递增的顺序排列。为作业分配存储空间时，从空闲区链的始端开始 109 *查找，选择第一个满足要求的空闲区，而不管它究竟有多大。*/ 110 if (str.equals("A")) { //-----------如果输入A,最先适应法 111 for (int j = 0; j < list.size(); j++) { 112 if (list.get(j).size >= pcbs.get(i).memory && list.get(j).station.equals("空闲")) { 113 Memorys memorys = new Memorys(); 114 list.get(j).setStation(name + "正在运行"); 115 int beyond = 0; //初始化beyond 116 beyond = list.get(j).size - pcbs.get(i).memory; //beyond=存储块大小-pcb的所占内存大小 117 if (beyond != 0) { 118 list.get(j).setSize(pcbs.get(i).memory); 119 list.add(j + 1, memorys); 120 list.get(j + 1).setName("子存储块"); 121 list.get(j + 1).setSize(beyond); 122 } 123 methid.print(list); 124 break; 125 } 126 } 127 } 128 /*最佳适应算法是从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区的一种计算方法，这种方法能使碎片尽量小。*/ 129 else if (str.equals("B")) { //----------------如果输入B，最佳适应法 130 Memorys memorys = new Memorys(); 131 int beyond = 100; 132 int ss = -1; 133 for (int j = 0; j < list.size(); j++) { 134 if (list.get(j).size >= pcbs.get(i).memory && list.get(j).station.equals("空闲")) { 135 if ((list.get(j).size - pcbs.get(i).memory) < beyond) { 136 beyond = list.get(j).size - pcbs.get(i).memory; 137 ss = j; 138 } 139 } 140 } 141 if (beyond != -1) { 142 list.get(ss).setStation(name + "正在运行"); 143 list.get(ss).setSize(pcbs.get(i).memory); 144 if (beyond != 0) { 145 list.add(ss + 1, memorys); 146 list.get(ss + 1).setName("子存储块"); 147 list.get(ss + 1).setSize(beyond); 148 } 149 } 150 methid.print(list); 151 break; 152 } 153 /*最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。该算法 154 * 要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。*/ 155 else if (str.equals("C")) { //-----------如果输入C，最坏适应法 156 Memorys memorys = new Memorys(); 157 int beyond = -1; 158 int ss = -1; 159 for (int j = 0; j < list.size(); j++) { 160 if (list.get(j).size > pcbs.get(i).memory && list.get(j).station.equals("空闲")) { 161 if ((list.get(j).size - pcbs.get(i).memory) > beyond) { 162 beyond = list.get(j).size - pcbs.get(i).memory; 163 ss = j; 164 } 165 } 166 167 } 168 if (ss != -1) { 169 list.get(ss).setStation(name + "正在运行"); 170 list.get(ss).setSize(pcbs.get(i).memory); 171 if (beyond != 0) { 172 list.add(ss + 1, memorys); 173 list.get(ss + 1).setName("字存储块"); 174 list.get(ss + 1).setSize(beyond); 175 } 176 } 177 methid.print(list); 178 break; 179 } 180 } 181 } 182 } else if (p == 2) { /*--------------------结束进程---------------*/ 183 System.out.println("请输入要结束的进程名"); 184 String name = input.next(); 185 String names = name + "正在运行"; 186 for (int i = 0; i < list.size(); i++) { 187 if (names.equals(list.get(i).station)) { 188 list.get(i).setStation("空闲"); 189 if (list.get(i + 1).name.equals("字存储块")) { 190 list.get(i).size = list.get(i).size + list.get(i + 1).size; 191 list.remove(i + 1); 192 } 193 methid.print(list); 194 break; 195 } 196 } 197 } else if (p == 0) { /*-----------------结束当前算法-------------------*/ 198 for (int i = 0; i < list.size(); i++) { 199 if (list.get(i).getStation() != "空闲") { 200 list.get(i).setStation("空闲"); 201 if (list.get(i + 1).name.equals("字存储块")) { 202 list.get(i).size = list.get(i).size + list.get(i + 1).size; 203 list.remove(i + 1); 204 } 205 } 206 } 207 break; 208 } 209 } 210 } 211 } 212 213 // ======================================主方法================================== 214 public class test { 215 private static Scanner input; 216 217 public static void main(String args[]) { 218 Vector<PCB> pcbs = new Vector<PCB>(); 219 System.out.println("请输入进程数："); 220 Scanner input = new Scanner(System.in); 221 int n = input.nextInt(); 222 for (int i = 0; i < n; i++) { 223 PCB pcb = new PCB(); 224 System.out.println("请输入第" + (i + 1) + "个进程的名字/运行所占内存用空格隔开"); 225 pcb.name = input.next(); 226 pcb.memory = input.nextInt(); 227 pcbs.add(pcb); 228 } 229 System.out.println("请定义存储块数，并为他们分配区间："); 230 int m = input.nextInt(); 231 ArrayList<Memorys> list = new ArrayList<Memorys>(); 232 for (int i = 0; i < m; i++) { 233 Memorys nck = new Memorys(); 234 System.out.println("请输入第" + (i + 1) + "个存储块的存储名和存储大小："); 235 nck.name = input.next(); 236 nck.size = input.nextInt(); 237 list.add(nck); 238 } 239 while (true) { 240 System.out.println("选择要采用的适配方法："); 241 System.out.println(" A:最先适应法"); 242 System.out.println(" B:最佳适应法"); 243 System.out.println(" C：最坏适应法"); 244 String str = input.next(); 245 Methid methid = new Methid(); 246 if (str.equals("A")) { 247 methid.swap(list); 248 methid.print(list); 249 Access access = new Access(); 250 access.mainMethid(str, pcbs, list); 251 } else if (str.equals("B")) { 252 methid.print(list); 253 Access access = new Access(); 254 access.mainMethid(str, pcbs, list); 255 256 } else if (str.equals("C")) { 257 methid.print(list); 258 Access access = new Access(); 259 access.mainMethid(str, pcbs, list); 260 } 261 } 262 } 263 }
实验结果如下：
1 请输入进程数： 2 3 3 请输入第1个进程的名字/运行所占内存用空格隔开 4 jincheng1 8 5 请输入第2个进程的名字/运行所占内存用空格隔开 6 jincheng2 4 7 请输入第3个进程的名字/运行所占内存用空格隔开 8 jincheng3 7 9 请定义存储块数，并为他们分配区间： 10 4 11 请输入第1个存储块的存储名和存储大小： 12 cuncu1 5 13 请输入第2个存储块的存储名和存储大小： 14 cuncu2 8 15 请输入第3个存储块的存储名和存储大小： 16 cuncu3 9 17 请输入第4个存储块的存储名和存储大小： 18 cuncu4 6 19 选择要采用的适配方法： 20 A:最先适应法 21 B:最佳适应法 22 C：最坏适应法 23 A 24 将存储块大小进行排序之后： 25 存储块名 存储大小 存储状态 26 cuncu1 5 空闲 27 cuncu4 6 空闲 28 cuncu2 8 空闲 29 cuncu3 9 空闲 30 请输入你要操作的步骤: 31 1:运行进程 2:结束进程 3:结束当前算法 32 请输入：1 33 请输入当前要运行的进程名 34 jincheng2 35 存储块名 存储大小 存储状态 36 cuncu1 4 jincheng2正在运行 37 子存储块 1 空闲 38 cuncu4 6 空闲 39 cuncu2 8 空闲 40 cuncu3 9 空闲 41 请输入你要操作的步骤: 42 1:运行进程 2:结束进程 3:结束当前算法 43 请输入：1 44 请输入当前要运行的进程名 45 jincheng3 46 存储块名 存储大小 存储状态 47 cuncu1 4 jincheng2正在运行 48 子存储块 1 空闲 49 cuncu4 6 空闲 50 cuncu2 7 jincheng3正在运行 51 子存储块 1 空闲 52 cuncu3 9 空闲 53 请输入你要操作的步骤: 54 1:运行进程 2:结束进程 3:结束当前算法 55 请输入：1 56 请输入当前要运行的进程名 57 jincheng1 58 存储块名 存储大小 存储状态 59 cuncu1 4 jincheng2正在运行 60 子存储块 1 空闲 61 cuncu4 6 空闲 62 cuncu2 7 jincheng3正在运行 63 子存储块 1 空闲 64 cuncu3 8 jincheng1正在运行 65 子存储块 1 空闲 66 请输入你要操作的步骤: 67 1:运行进程 2:结束进程 3:结束当前算法 68 请输入：2 69 请输入要结束的进程名 70 jincheng2 71 存储块名 存储大小 存储状态 72 cuncu1 4 空闲 73 子存储块 1 空闲 74 cuncu4 6 空闲 75 cuncu2 7 jincheng3正在运行 76 子存储块 1 空闲 77 cuncu3 8 jincheng1正在运行 78 子存储块 1 空闲 79 请输入你要操作的步骤: 80 1:运行进程 2:结束进程 3:结束当前算法 81 请输入：2 82 请输入要结束的进程名 83 jincheng3 84 存储块名 存储大小 存储状态 85 cuncu1 4 空闲 86 子存储块 1 空闲 87 cuncu4 6 空闲 88 cuncu2 7 空闲 89 子存储块 1 空闲 90 cuncu3 8 jincheng1正在运行 91 子存储块 1 空闲 92 请输入你要操作的步骤: 93 1:运行进程 2:结束进程 3:结束当前算法 94 请输入：2 95 请输入要结束的进程名 96 jincheng1 97 存储块名 存储大小 存储状态 98 cuncu1 4 空闲 99 子存储块 1 空闲 100 cuncu4 6 空闲 101 cuncu2 7 空闲 102 子存储块 1 空闲 103 cuncu3 8 空闲 104 子存储块 1 空闲 105 请输入你要操作的步骤: 106 1:运行进程 2:结束进程 3:结束当前算法 107 请输入：3 108 请输入你要操作的步骤: 109 1:运行进程 2:结束进程 3:结束当前算法 110 请输入：
