基于JAVA实现的操作系统模拟内存分配

Carewhose

发布日期: 2018-12-08 17:37:09 浏览量: 2395
评分：
star star star star star star star star star star
*转载请注明来自write-bug.com

第一章 概述

1.1 项目背景

  • 掌握内存分配FF，BF，WF策略及实现的思路

  • 掌握内存回收过程及实现思路

  • 实现内存的申请、释放的管理程序，调试运行，总结

1.2 编写目的

了解操作系统内存分配的算法。

1.3 开发环境

  • 系统环境：Windows 10

  • 开发IDE：intellij idea17.10

第二章 需求分析

2.1 问题陈述

  • 定义一个自由存储块链表，按块地址排序，表中记录块的大小。当请求分配内存时，扫描自由存储块链表，址到找到一个足够大的可供分配的内存块，若找到的块大小正好等于所请求的大小时，就把这一块从自由链表中取下来，返回给申请者。若找到的块太大，即对其分割，并从该块的高地址部分往低地址部分分割，取出大小合适的块返回给申请者，余下的低地址部分留在链表中。若找不到足够大的块，就从操作系统中请求另外一块足够大的内存区域，并把它链接到自由块链表中，然后再继续搜索。

    释放存储块也要搜索自由链表，目的是找到适当的位置将要释放的块插进去，如果被释放的块的任何一边与链表中的某一块临接，即对其进行合并操作，直到没有合并的临接块为止，这样可以防止存储空间变得过于零碎。

  • 空闲区采用分区说明表的方法实现上述的功能，要求同上。

2.2 功能分析

由问题陈述及需求设计6个模块：

2.2.1 内存初始化模块

主要用来初始化内存空间，并设置为空闲状态。

2.2.2 内存申请首次适应算法（First Fit）模块

从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。

2.2.3 内存申请最佳适应算法（Best Fit）模块

从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。该算法保留大的空闲区，但造成许多小的空闲区。

2.2.4 内存申请最差适应算法（Worst Fit）模块

从全部空闲区中找出能满足作业要求的、且大小最大的空闲分区，从而使链表中的结点大小趋于均匀，适用于请求分配的内存大小范围较窄的系统。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按大小从大到小进行排序，自表头开始查找到第一个满足要求的自由分区分配。该算法保留小的空闲区，尽量减少小的碎片产生。

2.2.5 内存返还模块

通过输入地址空间首地址返还内存，并设置为空闲状态。

2.2.6 随机初始化模块

主要是用来对三种算法进行可视化对比。

第三章 软件功能设计

3.1 模块实现

3.1.1 内存初始化模块

  1. public MyMemory() 
  2. {
  3.     init();
  4. }
  6. public static void init()
  7. {
  8.     myArray=new LinkedList<Mem>();
  9.     Mem mem=new Mem(0,GCON.totalMemory,true);
  10.     myArray.add(mem);
  11. }

3.1.2 内存申请首次适应算法（First Fit）模块

  1. /**
  2.      * 申请新的内存块 FF申请方式
  3.      * @param length 要申请块的大小
  4.      * @return 成功返回true,申请失败返回false
  5. */
  6. public static boolean getNewMem(int length)
  7. {
  8.     if(length>GCON.totalMemory||length<=0)
  9.         return false;
  10.     for(int i=0;i<myArray.size();i++)
  11.     {
  12.         if(myArray.get(i).state&&myArray.get(i).length>=length)
  13.         {
  14.             myArray.add(i+1,new Mem(myArray.get(i).start+myArray.get(i).length-length,length,false));
  15.             myArray.get(i).length-=length;
  16.             if(myArray.get(i).length==0)
  17.                  myArray.remove(i);
  18.             return true;
  19.         }
  20.     }
  21.     return false;
  22. }

3.1.3 内存申请最佳适应算法（Best Fit）模块

  1. /**
  2.      * BF方式申请内存
  3.      * @param length
  4.      * @return
  5. */
  6. public static boolean getNewMemBF(int length)
  7. {
  8.     if(length>GCON.totalMemory||length<=0)
  9.         return false;
  10.     int index=0,minLen=GCON.totalMemory+1;
  11.     for(int i=0;i<myArray.size();i++)
  12.     {     
  13.  if(myArray.get(i).state&&myArray.get(i).length>=length&&myArray.get(i).length<=minLen)
  14.         {
  15.             index=i;
  16.             minLen=myArray.get(i).length;
  17.         }
  18.     }
  19.     if(minLen==GCON.totalMemory+1)
  20.         return false;
  21.      if(minLen>=length)
  22.      {
  23.         myArray.add(index+1,new Mem(myArray.get(index).start+myArray.get(index).length-length,length,false));
  24.         myArray.get(index).length-=length;
  25. //      System.out.println(index+" "+myArray.get(index).length);
  26.         if(myArray.get(index).length==0)
  27.             myArray.remove(index);
  28.         return true;
  29.      }
  30.      return false;
  31. }

3.1.4 内存申请最差适应算法（Worst Fit）模块

  1. /**
  2.      * WF方式申请内存
  3.      * @param length
  4.      * @return
  5. */
  6. public static boolean getNewMemWF(int length)
  7. {
  8.      if(length>GCON.totalMemory||length<=0)
  9.         return false;
  10.      int index=0,maxLen=0;
  11.      for(int i=0;i<myArray.size();i++)
  12.      {
  13.          if(myArray.get(i).state&&myArray.get(i).length>=maxLen)
  14.          {
  15.             index=i;
  16.             maxLen=myArray.get(i).length;
  17.          }
  18.      }
  19.      if(maxLen<length)
  20.          return false;
  21.      else
  22.      {
  23.          myArray.add(index+1,new Mem(myArray.get(index).start+myArray.get(index).length-length,length,false));
  24.          myArray.get(index).length-=length;
  25.          if(myArray.get(index).length==0)
  26.             myArray.remove(index);
  27.          return true;
  28.      }
  29. }

3.1.5 内存返还模块

  1. /**
  2.      * 给内存的首地址，删除这个首地址的内存，就是把这个内存的占用状态改为空闲状态，并紧凑
  3.      * @param start 内存首地址
  4.      * @return 成功返回true，失败返回false
  5. */
  6. public static boolean delMem(int start)
  7. {
  8.     for(int i=0;i<myArray.size();i++)
  9.     {
  10.         if(myArray.get(i).start==start&&myArray.get(i).state==false)
  11.         {
  12.             myArray.get(i).state=true;
  13.             //往上紧凑
  14.             if(i<myArray.size()-1&&myArray.get(i+1).state)
  15.             {
  16.                 myArray.get(i).length+=myArray.get(i+1).length;
  17.                 myArray.remove(i+1);
  18.             }
  20.             //往下紧凑
  21.             if(i>0&&myArray.get(i-1).state)
  22.             {
  23.                 myArray.get(i-1).length+=myArray.get(i).length;
  24.                 myArray.remove(i);
  25.             }
  26.             return true;
  27.         }
  28.     }
  29.     return false;
  30. }

3.1.6 随机初始化模块

  1. /**
  2.  * 随机初始化
  3. */
  4. public static void initNew(int[] arr1)
  5. {
  6.     arr=arr1;
  7.     Random ran=new Random();
  8.     if(myArray!=null)
  9.         myArray.clear();
  10.     boolean flag=true;
  11.     int start=0;
  12.     for(int i=0;i<arr.length;i++)
  13.     {
  14.         int t=arr[i];
  15.         if(start+t<GCON.totalMemory-1)
  16.         {
  17.             myArray.add(new Mem(start,t,flag));
  18.         }
  19.         else
  20.         {
  21.             myArray.add(new Mem(start,GCON.totalMemory-start,flag));
  22.             start+=t;
  23.             break;
  24.         }
  25.         flag=!flag;
  26.         start+=t;
  27.     }
  28.     if(start<GCON.totalMemory-1)
  29.         myArray.add(new Mem(start,GCON.totalMemory-start,flag));
  30. }

第四章 界面设计

开始界面

选择内存分配方式

内存申请

内存返还

清除内存

内存随机初始化

更改总内存大小

清空面板信息

三种算法对比

对比结果

第五章 结束语

对于此次的操作系统课程的课程设计，加深了对大学所学的知识，但是由于本人缺乏系统的开发实际经验，对系统的分析还不够彻底，存在了很多缺陷，页面不够美观，没有专业的绘图知识，对代码的运用也不能够很熟的掌握，程序上也有很多需要改进的地方，在未来的日子里，还得要不断学习这方面知识，加深代码编写能力，吸收新的知识，提高自己的工作能力。

通过内存分配算法的编写，加强了我开发系统的能力，对于大学所学的知识又重新加深了了解，是一次很好的学习机会，特别感谢老师的指导！

第六章 参考文献

[1] 王珊, 萨师煊. 数据库系统概论(第4版). 高等教育出版社, 2006

[2] 彭伟民. 基于需求的酒店管理系统的建模与实现. 微机发展, 2005.10

上传的附件 cloud_download 基于JAVA实现的操作系统模拟内存分配.7z ( 2.62mb, 75次下载 )
error_outline 下载需要6点积分

keyboard_arrow_left上一篇 : 基于C语言实现的汽车牌照的快速查询 基于JAVA和ACCESS的综合测评系统(服务端和客户端) : 下一篇keyboard_arrow_right

comment 2
Carewhose
2018-12-08 17:36:40
操作系统模拟内存分配
mode_comment 评论(0)
empty
2018-12-13 14:46:23
有没有完整的包发一下
mode_comment 评论(1)

Carewhose

发送私信

你总是喊着努力努力，可是又坚持了多久

11
文章数
14
评论数
最近文章
highlight comment

Copyright @2020-WRITE-BUG.COM 技术支持 - YCY科技 - 备案/许可证编号：京ICP备16025663号-5

eject