实验要求：
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 = "\t" + this.name + "\t" + this.size + "\t" + 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("\t存储块名\t存储大小\t存储状态");
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 请输入：
时间： 2024-10-18 15:11:19