Java实现内存分配算法 FF(首次适应算法) BF(最佳适应算法)

一、概述

　　因为这次os作业对用户在控制台的输入输出有要求，所以我花了挺多的代码来完善控制台的显示。

　　MemoryAlgorithm类里只是和控制台输入输出有关的操作，而对内存的所有逻辑操作都是用Memory类里对应的方法实现的。

　　因为不同内存分配算法，只有对空闲分区表的排序不同，所以可以将FF和BF等内存分配算法一起实现。

　　

　　如果只关心和算法有关的核心代码的话，只看Memory类中add()、del()和sortFreeAreaList()方法即可。

　　添加和删除操作的逻辑比较绕，后面也有关于添加和删除操作单独的流程图。

二、运行结果

　　1. 测试数据：

（1）系统总内存为256，按下列参数分配内存

进程	1	2	3	4	5	6
所需内存	25	34	45	12	13	10

（2）依次回收进程2，4，3，6

（3）再次分配进程7，大小40

　　2. 测试结果：

　　（太长了，我就不截图了。测试的时候注意我的代码是按照请求回收内存的首地址进行回收的就行）

三、流程图

　　1. FF算法和BF算法的流程图

　　2. 添加进程的流程图

　　3. 撤销进程的流程图

四、实现代码

　　1. MemoryAlgorithm类（主类）

MemoryAlgorithm类只需要：

　　1.在适当的记录用户的输入；

　　2.根据用户的输入调用Memory类中对应的方法；

　　3.向用户反馈结果

所以这个类只是个界面。

 package xqy.algorithm;

 import java.util.*;

 import xqy.been.*;

 /**
  * @author xqy
  * @date 2018年12月20日21:36:40
  *
  */
 public class MemoryAlgorithm {
     private Memory memory;
     private String algType;
     private Scanner sc;

     /**
      * Each memory algorithm uses this class.<br/><br/>
      * Each memory algorithm is different only in free area's sorting. <br/><br/>
      * @param algType
      *         FF: First fit,
      *         BF: Best fit
      */
     public MemoryAlgorithm(String algType) {
         sc = new Scanner(System.in);
         this.algType = algType;

         init();
         op();
     }

     private void init() {
         int memorySize;
         int fragment;

         System.out.print("<" + algType + "> Please enter the memory size:");
         memorySize = sc.nextInt();

         System.out.print("<" + algType + "> Please enter the fragment allocated:");
         fragment = sc.nextInt();

         memory = new Memory(memorySize, fragment, algType);
     }

     private void op() {
         int key;

         while(true) {
             System.out.println("\n    #OPTION#");
             System.out.println("1.Add Job   2.Delete Job   3.Show Current Memory   4.Exit");
             System.out.print("<" + algType + "> Option:");
             key = sc.nextInt();
             if (key == 1) {
                 add();
             } else if (key == 2) {
                 del();
             } else if (key == 3) {
                 show();
             } else if (key == 4) {
                 System.out.println("    #EXIT#");
                 return;
             } else {
                 System.out.println("    #WRONG OPTION#");
             }
         }
     }

     private void add() {
         int key;

         while (true) {
             System.out.print("<" + algType + "-add> Please enter the job size (exit: -1):");
             key = sc.nextInt();

             if (key == -1) {
                 System.out.println("    #EXIT#");
                 return;
             } else if (key < 0) {
                 System.out.println("    #WRONG SIZE#");
             } else {

                 if (memory.add(key)) {
                     System.out.println("    #ADD RESULT# complete");
                 } else {
                     System.out.println("    #ADD RESULT# fail");
                 }

             }
         }
     }

     private void del() {
         int key;

         while (true) {
             System.out.print("<" + algType + "-del> Please enter the job first address (exit: -1):");
             key = sc.nextInt();

             if (key == -1) {
                 System.out.println("    #EXIT#");
                 return;
             } else if (key < 0 || key >= memory.size()) {
                 System.out.println("    #WRONG ADDRESS#");
             } else {

                 if (memory.del(key)) {
                     System.out.println("    #DEL RESULT# complete");
                 } else {
                     System.out.println("    #DEL RESULT# fail");
                 }
             }
         }

     }

     private void show() {
         System.out.println("<" + algType + "-current memory>");
         System.out.print(memory.toString());
     }

     public static void main(String [] args) {
         Scanner sc = new Scanner(System.in);
         int key;

         while (true) {
             System.out.println("\n    #OPTION#");
             System.out.println("1.FF   2.BF   3.Exit");
             System.out.print("Option:");
             key = sc.nextInt();

             if (key == 1) {
                 new MemoryAlgorithm("FF");
             } else if (key == 2) {
                 new MemoryAlgorithm("BF");
             } else if (key == 3) {
                 System.out.println("    #EXIT#");
                 break;
             } else {
                 System.out.println("    #WRONG OPTION#");
             }
         }
     }
 }

　　2. Memory类

Memory类实现了：

　　1) 对内存相应属性的封装；

　　2) 对内存的操作：

　　　　a) add() --> 添加作业分配内存；

　　　　b) del() --> 撤销作业释放内存；

　　　　c) toString() --> 展示内存的信息；

　　　　d) sortFreeAreaList() --> 根据用户选择的内存分配算法，对“空闲空间表”进行排序（不同算法间，唯一的不同）

 package xqy.been;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;

 public class Memory {
     private int size;
     private int fragment;
     private String algType;
     private ArrayList<Area> freeAreaList;
     private ArrayList<Area> usedAreaList;

     public Memory(int size, int fragment, String algType) {
         this.size = size;
         this.fragment = fragment;
         this.algType = algType;
         this.freeAreaList = new ArrayList<Area>();
         this.usedAreaList = new ArrayList<Area>();

         this.freeAreaList.add(new Area(size, 0, true));
     }

     public boolean add(int newJobSize) {
         boolean canAdd = false;
         Area opFreeArea;

         for (int i = 0; i < freeAreaList.size(); i++) {
             opFreeArea = freeAreaList.get(i);

             if (newJobSize > opFreeArea.size()) {
                 ;
             } else {
                 if ((opFreeArea.size() - newJobSize) <= fragment) {
                     usedAreaList.add(new Area(opFreeArea.size(), opFreeArea.getAddress(), false));
                     freeAreaList.remove(i);
                 } else {
                     int newAreaSize = opFreeArea.size() - newJobSize;
                     int newAreaAddress = opFreeArea.getAddress() + newJobSize;
                     Area newFreeArea = new Area(newAreaSize, newAreaAddress, true);

                     usedAreaList.add(new Area(newJobSize, opFreeArea.getAddress(), false));
                     freeAreaList.remove(i);
                     freeAreaList.add(i, newFreeArea);
                 }

                 canAdd = true;
                 sortFreeAreaList();

                 break;
             }
         }

         return canAdd;
     }

     /**
      * Delete job according to job`s first address.<br/><br/>
      *
      * If the address you entered don`t fit any used area`s first address, can`t delete.<br/><br/>
      *
      * If the address you entered is fight:<br/>
      * <ul>
      *         <li>Case 1: Previous area and next area are both free.</li>
      *             <ul>
      *                 <li>1.修改状态</li>
      *                 <li>2.从used area list中删去，加进free area list</li>
      *             </ul>
      *         <li>Case 2: Previous area and next area are both used.</li>
      *             <ul>
      *                 <li>1.修改最前面的分区 更改size（三个区的size之和）</li>
      *                 <li>2.从free area list 中将next free area 删除</li>
      *                 <li>3.从used area list 中将相应area 删除</li>
      *             </ul>
      *         <li>Case 3: Previous area is free, and next area is used.</li>
      *             <ul>
      *                 <li>1.修改前面的分区 更改size（将前面分区的size和要删除分区的size合并）</li>
      *                 <li>2.从used area list中将相应area删除</li>
      *             </ul>
      *         <li>Case 4: Previous are is used, and next area is free.</li>
      *             <ul>
      *                 <li>1.修改后面的分区
      *                     <ul>
      *                         <li>(1)更改size（将要删除的分区的size和后面分区的size合并</li>
      *                         <li>(2)更改address-->改成要删除分区的address </li>
      *                    </ul>
      *                 <li>2.从used area list中将相应area删除</li>
      *             </ul>
      * </ul>
      * @param delJobAddress
      * @return
      */
     public boolean del(int delJobAddress) {
         boolean canDel = false;
         int delAreaIndex = -1;

         for (int i = 0; i < usedAreaList.size(); i++) {
             if (delJobAddress == usedAreaList.get(i).getAddress()) {
                 canDel = true;
                 delAreaIndex = i;
             }
         }

         if (canDel == true) {
             int previousFreeAreaIndex = calcPreviousFreeAreaIndex(delJobAddress);
             int nextFreeAreaIndex = calcNextFreeAreaIndex(delJobAddress, usedAreaList.get(delAreaIndex).size());

             if ((previousFreeAreaIndex == -1) && (nextFreeAreaIndex == -1)) { // case 1
                 Area a = usedAreaList.get(delAreaIndex);
                 a.setFree(true);

                 usedAreaList.remove(delAreaIndex);
                 freeAreaList.add(a);
             } else if ((previousFreeAreaIndex >= 0) && (nextFreeAreaIndex >= 0)) { // case 2
                 Area preArea = freeAreaList.get(previousFreeAreaIndex);
                 Area needDelArea = usedAreaList.get(delAreaIndex);
                 Area nextArea = freeAreaList.get(nextFreeAreaIndex);
                 preArea.setSize(preArea.size() + needDelArea.size() + nextArea.size());

                 freeAreaList.remove(nextFreeAreaIndex);
                 usedAreaList.remove(delAreaIndex);
             } else if (previousFreeAreaIndex >= 0) { // case 3
                 Area area = freeAreaList.get(previousFreeAreaIndex);
                 area.setSize(area.size() + usedAreaList.get(delAreaIndex).size());
                 usedAreaList.remove(delAreaIndex);
             } else if (nextFreeAreaIndex >= 0) { // case 4
                 Area area = freeAreaList.get(nextFreeAreaIndex);
                 area.setSize(area.size() + usedAreaList.get(delAreaIndex).size());
                 area.setAddress(usedAreaList.get(delAreaIndex).getAddress());
                 usedAreaList.remove(delAreaIndex);
             }

             sortFreeAreaList();
         }

         return canDel;
     }

     private int calcPreviousFreeAreaIndex(int address) {
         int index = -1;

         for (int i = 0; i < freeAreaList.size(); i++) {
             if ((freeAreaList.get(i).getAddress() + freeAreaList.get(i).size()) == address) {
                 index = i;
             }
         }

         return index;
     }

     private int calcNextFreeAreaIndex(int address, int size) {
         int index = -1;

         for (int i = 0; i < freeAreaList.size(); i++) {
             if (freeAreaList.get(i).getAddress() == (address + size)) {
                 index = i;
             }
         }

         return index;
     }

     private void sortFreeAreaList() {
         if (algType.equals("FF")) {
             Collections.sort(freeAreaList, new SortByAddress());
         } else if (algType.equals("BF")) {
             Collections.sort(freeAreaList, new SortBySize());
         }
     }

     public int size() {
         return size;
     }

     public ArrayList<Area> getFreeAreaList() {
         return freeAreaList;
     }

     @SuppressWarnings("unchecked") // 给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默
     @Override
     public String toString() {
         ArrayList<Area> list = new ArrayList<Area>();
         list.addAll((ArrayList<Area>)freeAreaList.clone());
         list.addAll((ArrayList<Area>)usedAreaList.clone());
         Collections.sort(list, new SortByAddress());

         String str = "    Current memory:\n";
         for (int i = 0; i < list.size(); i++) {
             str += "    [Area] "
                     + "address=" + list.get(i).getAddress() + "-" + (list.get(i).getAddress() + list.get(i).size() - 1)
                     + " size=" + list.get(i).size()
                     + ((list.get(i).isFree()) ? " free\n" : " used\n");
         }

         str += "    Free area List:\n";
         if (freeAreaList.size() == 0) {
             str += "    null\n";
         } else {
             for (int i = 0; i < freeAreaList.size(); i++) {
                 str += "    [Area] " + "address=" + freeAreaList.get(i).getAddress() + "-"
                         + (freeAreaList.get(i).getAddress() + freeAreaList.get(i).size() - 1)
                         + " size=" + freeAreaList.get(i).size() + "\n";
             }
         }
         return str;
     }
 }

 class SortBySize implements Comparator<Area> {
     public int compare(Area a1, Area a2) {
         if (a1.size() > a2.size())
             return 1;
         return -1;
     }
 }

 class SortByAddress implements Comparator<Area> {
     public int compare(Area a1, Area a2) {
         if (a1.getAddress() > a2.getAddress())
             return 1;
         return -1;
     }
 }