Fork me on GitHub

存储器的分配与回收算法实现

实验要求：

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 请输入：

 

posted @ 2015-12-25 23:36  ZepheryWen  阅读(3579)  评论(1)  编辑  收藏  举报