页面置换算法最佳页面置换算法模拟JAVA实现

最新推荐文章于 2023-05-23 11:07:41 发布
最新推荐文章于 2023-05-23 11:07:41 发布
阅读量2.8k 收藏 21
点赞数 4
文章标签： 操作系统 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56052440/article/details/121337430
版权

操作系统存储管理页面置换算法-----最佳页面置换算法模拟（JAVA实现）

话不多说，我们直接展示

package com.company;

import java.util.Arrays;

/**
 * @Auther: Bender
 * @Date: 2021/11/14 - 16:57
 * @Description: com.company
 * @version: 1.0
 */

//注释掉的是第一次做的程序，考虑不充分失败了
public class MyAlg {
    public static boolean isIn(int a, int[] arr) {                  //判断某个数是否在数组中，返回true或者false
        for(int i: arr){
            if(a==i){
                return true;
            }
        }
        return false;

    }

    public static int isIn(int[] arr, int a) {                      //isIn方法重载，返回相等元素的数组下标，没有则返回下标
        for(int i=0; i<arr.length; i++){
            if(arr[i] == a)
                return i;
        }
        return -1;

    }
    public static void optAdd(int[] contain, int[]list, int k) {                //最佳置换算法的缺页处理（前提：内存区已满）
        /*分析：应该分为多种情况，******需要注意的是当作业队列中出现多次已经存在内存中的作业时（例子：内存区[5,6,7]   作业队列[1,6,7,6]）,我们只取第一个******
        1.当后续作业队列中没有找到内存中已有的作业时
          例子：内存区[6,7,8]   作业队列[1,2,3,4,5]
          处理方式：默认替换0号元素
        2.当后续作业队列中找到一个已经在内存中存在的作业时
          例子：内存区[1,2,3]   作业队列[5,6,7,1,8]
          处理方式：从0号元素开始，将未在作业队列中的元素依次替换
        3、当后续作业队列中找到两个已经在内存中存在的作业时
          例子：内存区[5,6,7]   作业队列[8,5,6]
          处理方式：直接替换掉未出现的元素
        4.当后续作业队列中找到内存区所有元素
          例子：内存区[5,6,7]    作业队列[8,5,6,7]
          处理方式：替换掉最后出现的元素
         */
        int[] index = {-3,-3,-3};                           //要返回的下标队列，选取其中最小的值作为第k个元素要替换的下标******
        int inum = 3;                                       //给index中的元素复制，随着赋值次数递减，最小的就是要替换的
        int goalindex = 0;
        for(int i=k+1; i<list.length; i++){                 //从k的下一个元素开始遍历，原因：第K个元素调用此方法的前提是这个元素并不在内存中
            if(isIn(list[i],contain)){                      //该元素在内存中
                int num = isIn(contain,list[i]);            //返回相同的元素下标

                if(index[num]==-3)                          //确保只取第一次，后续忽略
                    index[num] = inum--;
            }
        }
        if(index[0]<0 && index[1]<0 && index[2]<0 ){  //情况一：默认替换第0个元素
            index[0] = -4;
        }
        int temp = index[0];
        for(int i=1; i<index.length; i++){              //找出index中的最小值
            if(index[i]<temp) {
                temp = index[i];
                goalindex = i;
            }

        }
        contain[goalindex] = list[k];
        System.out.println("缺页中断"+ Arrays.toString(contain));


    }
    public static void opt(int[] list) {
        System.out.println("-----这是最佳页面置换算法-----");
        int times = 0;                      //记录缺页率
        int[] contain = new int[3];         //模拟内存空间，大小为3
        int isempty = 0;                    //对contain模拟内存中的元素进行计数
        /*此循环的作用：将contain模拟内存装满

         */
        int i;                                          //在循环体外定义循环变量i是为了当循环结束时返回i的值（当内存区满后，对作业队列的执行从i+1开始）
        for(i=0; i<list.length; i++) {
            if(!isIn(list[i],contain)){                  //当要放入的元素不在内存区中
                contain[isempty] = list[i];
                isempty++;                              //内存区元素加一
                System.out.println("缺页中断"+Arrays.toString(contain));
                times++;
                if(isempty==3) {                         //当内存区的元素个数为3（内存区已满的情况）即可跳出此循环
                    break;
                }
            }//当要访问的元素在内存区已经存在时，我们不做任何操作
        }
        //执行至此处内存区已满，下面对作业队列遍历，缺页时执行页面置换操作，不缺页时不做任何操作
        //具体的页面置换我希望单独设计成一个方法（前提：内存区此时已满，不达成这个前提，程序设计会复杂的多）
        for(++i; i<list.length; i++){                   //从上一个循环的下一个位置开始遍历作业队列
            if(!isIn(list[i],contain)){                 //缺页时的操作
                optAdd(contain,list,i);
                times++;
            }//不缺页不执行任何操作

        }
        System.out.println("缺页次数:" + times + ",缺页中断率:" + (float)times / list.length);

    }
//    public static int search(int[] contain, int[] arr, int index){      //返回在之后的作业队列中，内存中最后一个被访问的内存块的下标
//        int renum = 0;                                              //最后该方法的返回值，指明要替换的主存块
//        for(int i=index; i<arr.length; i++){                        //对之后的作业队列进行遍历
//            int num = isIn(contain,arr[i]);
//            if(num!=-1)
//                renum = num;
//        }
//        return renum;

//    }

//    public static void opt(int[] arr) {
//        System.out.println("-----这是最佳置换算法-----");
//        System.out.println("作业队列："+Arrays.toString(arr));
//        int times = 0;                          //用于记录置换次数（缺页中断次数），计算缺页率
//        int elements = 0;                       //记录内存中的作业数
//        int[] contain = new int[3];             //模拟主存空间
        for(int i=0; i<3; i++){                 //三个作业装入，现在主存装满
            contain[i] = arr[i];
        }
//        contain[0] = arr[0];                    //先将第一个作业放入内存
//        times++;                                 //缺页中断次数加一
//        elements++;                              //内存作业数加一，变为1
//        System.out.println("主存块："+Arrays.toString(contain));
//        for(int i=1; i<arr.length; i++){           //遍历作业队列
//            if(!isIn(arr[i],contain)){              //当要访问的作业不在主存时
//                times++;                            //缺页终断率加一
//                if(elements>=3){                     //内存已满
                    int index = search(contain,arr,i);
                    contain[index] = arr[i];
//                    System.out.println("中断："+times+"次，"+Arrays.toString(contain));                   //打印置换后的内存情况
//                }else{                              //内存未满，直接加如内存
//                    contain[elements] = arr[i];
//                    elements++;
//                }
//            }else{                                  //当要访问的作业就在内存时，将被访问的作业调至最后，其他作业依次向前移，因为当后续作业队列中的作业都不在主存时，默认替换主存数组的第0个元素（即距离上次调用的时间最长）
//                if(elements>=3){                    //内存区已满的情况
//                    int index = isIn(contain,arr[i]);
//                    if(index==1){
//                        int temp = contain[1];
//                        contain[1] = contain[2];
//                        contain[2] = temp;
//                    }else if(index == 0){
//                        int temp = contain[0];
//                        contain[0] = contain[1];
//                        contain[1] = contain[2];
//                        contain[2] = temp;
//                    }
//                    System.out.println("未发生中断"+Arrays.toString(contain));
//                }
//            }
//            System.out.println("主存块："+Arrays.toString(contain));
//
//        }
//
//    }

    public static void main(String[] args) {
        int[] arr = {6,7,6,5,9,6,8,9,7,6,9,6};
        opt(arr);
    }
}

运行结果的展示：
在这里插入图片描述
看了这篇页面置换算法的文章，试运行了一下发现错误很多，很多点没有考虑到，所以自己重写了一下
链接: https://blog.csdn.net/TianXiaobie/article/details/110451353?utm_source=app&app_version=4.18.0&code=app_1562916241&uLinkId=usr1mkqgl919blen.

Call me Bender
关注
  • 4
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
java实现页面置换算法
08-18
主要为大家详细介绍了java实现页面置换算法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
实现页面置换的算法（OPT，FIFO，LRU）Java版
m0_54853420的博客
06-22 2377
定义：OPT（最佳置换算法）：从主存中移出永远不再需要的页面，如果没有这样的页面存在，那就选择最长时间不需要访问的页面，来保证最低的缺页率。 FIFO算法 定义：该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 LRU算法 定义：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 最后合在一起，测试一下，代码如下： 测试结果如下： 实验测试结果的表格版： OPT： FIFO： LR
页面置换算法JAVA
m0_63445876的博客
04-14 692
页面置换算法
操作系统之-页面置换算法（java代码模拟）
辉之素狂
06-15 4263
一：页面置换算法简介 在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无 空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据送磁盘 的对换区中。但应将哪个页面调出，须根据一定的算法来确定。通常，把选择换出页面的 算法称为页面置换算法(Page-Replacement Algorithms)。置换算法的好坏，将直接影响到系统 的性能。 一个好的页面置换算法，应具有较低的页面更换频率。从理论上讲，应将那些以后不 再会访问的页面换出，或把那些在较长时间内
页面置换算法（java）
02-26
在一个请求分页系统中，分别采用最佳置换算法、先进先出置换算法、最近最久未使用置换算法(LRU)时，假如一个作业的页面走向为4、3、2、1、4、3、5、4、3、2、1、5，当分配给该作业的物理块数M分别为3和4时，试计算在...
页面置换算法的模拟实现及命中率对比
02-02
通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储技术的特点，掌握请 求页式存储管理中的页面置换算法。 容 二、课程设计内容 模拟实现 OPT（最佳置换）、FIFO 和 LRU 算法，并计算缺页率。 示 三、要求...
操作系统实验：页面置换算法的模拟实现及命中率对比.rar
06-28
本资源使用Java实现了页面置换算法OPT、FIFO、LRU的模拟实现以及FIFO和LRU的命中率对比，内容包括Java源项目、jar包和bat文件。该资源的文字版信息请访问博客《操作系统实验：页面置换算法的模拟实现及命中率对比...
Java页面置换算法模拟程序（FIFO、LRU）
06-07
页面置换算法的模拟程序。用随机数方法产生页面走向，根据页面走向，分别采用FIFO和LRU算法进行页面置换，统计缺页率。
操作系统-页面置换算法的模拟实现及命中率对比
12-25
实验报告 内涵代码（1）、通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储 术的特点，掌握请求页式存储管理中的页面置换算法。 （2）、课程设计内容 模拟实现OPT（最佳置换）、FIFO和LRU算法，并计算命中率。 （3） 、课程设计要求：
页面置换算法模拟实现及命中率对比
01-23
lru opt fifo 三种算法的模拟实现（有详细置换过程）
【OS学习笔记】页面置换算法的Java版实现
qq_44654974的博客
05-23 690
一、背景 程序的运行，需要将指令和数据装入内存中进行执行，可内存的资源十分有限（目前常用的差不多8G,16G）。而虚拟内存就是解决该问题的。 局部性原理：（1）时间局部性：程序中的某条指令一旦执行或数据访问，不久后会再次执行或访问。典型原因是循环操作 （2）空间局部性：程序在一段时间内访问的地址在一定范围内。 基于局部性原理，在程序装入时，将程序的一部分装入内存，而将其余部分留在外存，启动程序执行。当所访问的信息不在内存时，由OS将所需的部分调入内存，暂时不需要的内容换出（置换）到外存上。 二、置换
操作系统--三种页面置换算法（java实现）
qr_01的博客
11-19 1214
三种页面置换算法 OPT FIFO LRU
页面置换算法综合实现（Java，Java Swing实现）
我家有只小金毛的博客
12-27 4254
页面置换算法综合实现（Java，Java Swing）算法导入算法分析一、界面分析二、界面设计三、界面相关算法设计算法展示一、操作展示二、算法比较结尾 算法导入        失踪人口回归！先聊聊闲话哈！        最近在看《夏目友人帐》，真香，猫老师太萌......
详细分析置换算法
夜尽天明
05-23 750
对于操作系统而言，虚拟空间是非常大的，我们往往无法直接将如此大的空间装入内存，而即使我们采用多级页表与段页式存储即使，也仅仅只是节省了页表的大小，如此将如何多的物理页装进内存仍然是一个问题，为此科学家们提出了一种动态的思想，当剩余空间不够装入新页面时，操作系统就选择适当的页将其刷新回磁盘(如果确实是脏页的话，如果不是脏页则仅仅只是覆盖)，以此空出空间装入新页，而这则需要运用到页面置换算法。还有一个问题是：是否需要对每一个进程固定一个空间大小，换句话说，是采用策略还是策略。
页面置换算法java_页面置换算法之Clock算法
weixin_42509293的博客
02-16 1054
1.前言缓冲池是数据库最终的概念，数据库可以将一部分数据页放在内存中形成缓冲池，当需要一个数据页时，首先检查内存中的缓冲池是否有这个页面，如果有则直接命中返回，没有则从磁盘中读取这一页，然后缓存到内存并返回。但是内存的价值较高，一般来说服务器的内存总是小于磁盘大小的，而且内存不能完全分配给数据库作为缓冲池。这就意味着数据库基本上无法将所有的数据都缓冲到内存中。当缓冲池满后，如果还有新的页面要被缓冲...
java实现的页面置换算法
热门推荐
cnkeysky的博客
06-10 1万+
java实现的页面置换算法，包括FIFO、LRU、Clock三种算法
fifo页面置换算法java_操作系统页面置换算法(opt,lru,fifo,clock)实现
weixin_39524882的博客
02-17 437
#include #include#include#include#include#include#include#define N 200using namespacestd;int page[N];//页面引用号int block[N];//物理块，内存int dist[N][N];//表示第i次访问内存的时候，内存中的页面j 在以后被访问的最小时间int n;//页面引用号个数int m;/...
Java页面置换算法的模拟实现
最新发布
06-09
好的，以下是Java页面置换算法的模拟实现： ```java import java.util.Scanner; public class PageReplacement { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入内存块大小："); int blockSize = scanner.nextInt(); System.out.print("请输入页面序列长度："); int sequenceLength = scanner.nextInt(); int[] sequence = new int[sequenceLength]; System.out.println("请输入页面序列："); for (int i = 0; i < sequenceLength; i++) { sequence[i] = scanner.nextInt(); } System.out.println("请选择页面置换算法："); System.out.println("1. 先进先出算法（FIFO）"); System.out.println("2. 最佳置换算法（OPT）"); System.out.println("3. 最近最久未使用算法（LRU）"); int algorithm = scanner.nextInt(); switch (algorithm) { case 1: fifo(blockSize, sequence); break; case 2: opt(blockSize, sequence); break; case 3: lru(blockSize, sequence); break; default: System.out.println("无效的算法选择！"); break; } } // 先进先出算法（FIFO） private static void fifo(int blockSize, int[] sequence) { int[] memory = new int[blockSize]; // 内存块 int pointer = 0; // 内存块指针 int missCount = 0; // 缺页计数器 for (int i = 0; i < sequence.length; i++) { int page = sequence[i]; // 判断页面是否已经在内存中 boolean isInMemory = false; for (int j = 0; j < blockSize; j++) { if (memory[j] == page) { isInMemory = true; break; } } // 页面未在内存中，需要进行页面置换 if (!isInMemory) { missCount++; memory[pointer] = page; pointer = (pointer + 1) % blockSize; } } System.out.println("FIFO算法缺页次数：" + missCount); } // 最佳置换算法（OPT） private static void opt(int blockSize, int[] sequence) { int[] memory = new int[blockSize]; // 内存块 int missCount = 0; // 缺页计数器 for (int i = 0; i < sequence.length; i++) { int page = sequence[i]; // 判断页面是否已经在内存中 boolean isInMemory = false; for (int j = 0; j < blockSize; j++) { if (memory[j] == page) { isInMemory = true; break; } } // 页面未在内存中，需要进行页面置换 if (!isInMemory) { missCount++; // 找到后面最长时间不使用的页面进行置换 int maxDistance = 0; int maxIndex = -1; for (int j = 0; j < blockSize; j++) { int pageInMemory = memory[j]; int distance = Integer.MAX_VALUE; // 计算页面距离下一次使用的距离 for (int k = i + 1; k < sequence.length; k++) { if (sequence[k] == pageInMemory) { distance = k - i; break; } } if (distance > maxDistance) { maxDistance = distance; maxIndex = j; } } memory[maxIndex] = page; } } System.out.println("OPT算法缺页次数：" + missCount); } // 最近最久未使用算法（LRU） private static void lru(int blockSize, int[] sequence) { int[] memory = new int[blockSize]; // 内存块 int[] counter = new int[blockSize]; // 计数器 int missCount = 0; // 缺页计数器 for (int i = 0; i < sequence.length; i++) { int page = sequence[i]; // 判断页面是否已经在内存中 boolean isInMemory = false; int indexInMemory = -1; for (int j = 0; j < blockSize; j++) { if (memory[j] == page) { isInMemory = true; indexInMemory = j; break; } } // 页面未在内存中，需要进行页面置换 if (!isInMemory) { missCount++; // 寻找最近最久未使用的页面进行置换 int minCounter = Integer.MAX_VALUE; int minIndex = -1; for (int j = 0; j < blockSize; j++) { if (counter[j] < minCounter) { minCounter = counter[j]; minIndex = j; } } memory[minIndex] = page; counter[minIndex] = 0; } else { counter[indexInMemory]++; } // 所有页面计数器加一 for (int j = 0; j < blockSize; j++) { counter[j]++; } } System.out.println("LRU算法缺页次数：" + missCount); } } ``` 在程序中，先让用户输入内存块大小、页面序列长度和页面序列，然后让用户选择页面置换算法，程序会根据用户的选择进行相应的页面置换操作，并输出缺页次数。其中，实现了三种页面置换算法：先进先出算法（FIFO）、最佳置换算法（OPT）和最近最久未使用算法（LRU）。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值