操作系统 LFU：最不经常使用(最少次)淘汰算法（Least Frequently Used） 用JAVA高级语言模拟 详细注释

已于 2023-12-17 01:44:59 修改
阅读量672 收藏 9
点赞数 5
分类专栏： Java 文章标签： java 算法 开发语言
于 2023-12-11 01:33:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ATsar/article/details/134917574
版权
本文介绍了LeastFrequentlyUsed(LFU)淘汰算法的应用，通过模拟用户输入的页面访问顺序，动态管理内存中的存储区块，计算缺页率。程序演示了两种不同存储区块数下的页面调度过程。
摘要由CSDN通过智能技术生成

LFU：最不经常使用(最少次)淘汰算法（Least Frequently Used）。LFU是淘汰一段时间内，使用次数最少的页面。

package HomeWork_OS.LRU;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class LFU_os {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("请输入存储区块数: ");
        int userInput = sc.nextInt();
        int[] brickArr = new int[userInput]; //元素默认都为0

        int indexNum = 1;
        StringBuffer sb = new StringBuffer();
        System.out.println("请输入页号走向(输入0结束): ");
        while(userInput!= 0){
            System.out.print("页面序号" +indexNum + ": " );
            userInput = sc.nextInt();
            sb.append(userInput);
            indexNum++;
        }
        System.out.println("输入结束" +
                "\n置换情况如下: ");
//        System.out.println("sb = " + sb.toString());



        String str = sb.toString();
        char arr1[] = str.toCharArray();    //将用户输入转换成字符串数组
        //页面数组
        int[][] arr = new int[(arr1.length)][2];
//		System.out.println("arr1.length = " + arr1.length);
//		System.out.println("arr.length = " + arr.length);
//      System.out.println("打印arr1 " + Arrays.toString(arr1));
//		System.out.println("indexArr1 = " + indexArr1);

        double pageFaultRate;              //缺页率
        int pageNum = arr1.length - 1;      //总页面数
        int pageFaultCount = 0;         //缺页次数

        int pageIndex = 1;//页面序号
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (j == 0 ){   //二维数组第一项存页面序号
                    arr[i][j] = pageIndex++;
                }else{  //二维数组第二项存页号
                    arr[i][j] = Integer.parseInt(String.valueOf(arr1[i]));  //将字符串数组转换成整型数组,存入到二维数组每一行的第二项中
                }
            }
        }

        //打印页面数组
       /* System.out.println("打印页面数组:");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (j == 0 ){
                    System.out.print( "页面" + arr[i][j] + "  ");
                }else{
                    System.out.println(arr[i][j] );
                }
            }
        }*/

        //建立一个存储页面序号和已访问次数的Map集合
        //页号为key,访问次数为value
        Map<Integer,Integer> map = new HashMap<>();

        boolean flagPage;//false 表示元素不存在brickArr中,true 表示存在
        for (int k = 0; k < arr.length; k++) {   //遍历页面数组
            if (arr[k][1] == 0){ //遍历到最后一个元素0的时候退出循环
                break;
            }

            //查找该页面是否存在
            Integer getKey =  map.get(arr[k][1]);
            if (getKey == null){  //如果当前页面不存在map集合中,则添加到该集合中
                map.put(arr[k][1],1);
            }else { //如果当前页面在map集合中,则将其的值加一
                Integer value = map.remove(arr[k][1]) + 1;
                map.put(arr[k][1],value);
            }

            flagPage = false; //设立一个标志位标识存储区块数组中是否存在该元素
            for (int i = 0; i < brickArr.length; i++) {  //遍历存储区块数组
                if(brickArr[i] == 0){   //当存储区块数组中的元素为0时,表示为空,可以直接调入页面
                    brickArr[i] = arr[k][1];
                    pageFaultCount++;//缺页次数加一
                    flagPage = false;
                    System.out.println("发生缺页中断,但内存中有空闲区," + arr[k][1] +"号页面直接调入!");
                    break;
                }else if (brickArr[i] == arr[k][1]){    //如果存储区块数组中有该元素,则结束内循环,继续遍历页面数组中的下一个元素
                    flagPage = false;
                    System.out.println("内存中有" + arr[k][1] + "号页面，无须缺页中断！");
                    break;
                }else{  //如果存储区块数组中没有该元素,将标识位修改为true
                    flagPage = true;
                }
            }

            if (flagPage){
                pageFaultCount++;//缺页次数加一

                //找出最近最久未使用的页面替换出去
                //存储map中birckArr中的页面号和出现次数
                int[][] minCountPage = new int[brickArr.length][2];

                //遍历存储区块数组元素
                for (int i = 0; i < minCountPage.length; i++) {
                        Integer getValue = map.get(brickArr[i]);  //获取该map元素的值(页面出现的次数)
                        minCountPage[i][0] = brickArr[i];         //存入最少出现次数页面号
                        minCountPage[i][1] = getValue;            //存入最少出现次数页面次数
                }

                //获取出现次数最小的页面值和页面号
                //赋数组最后的数为默认最小值
                int minPageValue = minCountPage[0][1],minPageNumKey = minCountPage[0][0];
                for (int i = 1; i < minCountPage.length; i++) {
                    if (minPageValue > minCountPage[i][1]){
                        minPageValue = minCountPage[i][1];
                        minPageNumKey = minCountPage[i][0];//获取最小value的页面号
                    }
                }

                //获取存储区块数组中历史出现次数最少的页面,在存储区块数组中的索引
                int brickArrMinPageIndex = 0;
                for (int i = 1; i < brickArr.length; i++) {
                    if (brickArr[i] == minPageNumKey){
                        brickArrMinPageIndex = i;
                        break;
                    }
                }

                System.out.println("发生缺页中断，将" + brickArr[brickArrMinPageIndex] + "号页面调出，" +
                        arr[k][1] + "号装入！");

                //存储区块数组中元素挪动替换
                for (int i = 0; i < brickArr.length; i++) {
                    //将当前要添加的页面放到存储区块数组最后
                    if (i == brickArr.length - 1){
                        brickArr[i] = arr[k][1];
                    }else if (i >= brickArrMinPageIndex){
                        brickArr[i] = brickArr[i + 1];
                    }else
                        continue;
                }
            }

            /*打印存储区块数数组*/
/*            System.out.print("打印brickArr:  ");
            for (int i : brickArr) {
                System.out.print(i + " ");
            }
            System.out.println();
            System.out.println("遍历map:");
            for (Integer key : map.keySet()) {
                Integer value = map.get(key);
                System.out.print ("key:" + key + " value: "+ value + "\n");
            }
            System.out.println();*/

        }

        pageFaultRate = (double)pageFaultCount / pageNum * 100;         //缺页率
        System.out.println("页号" + pageNum +
                "个，缺页中断" + pageFaultCount +
                "次，缺页率:" + String.format("%.4f",pageFaultRate) +
                "%");

    }
}

程序调试：

调试一：

请输入存储区块数：3

请输入页号走向（输入0结束）：

页面序号1： 4

页面序号2： 3

页面序号3： 2

页面序号4： 1

页面序号5： 4

页面序号6： 3

页面序号7： 5

页面序号8： 4

页面序号9： 3

页面序号10： 2

页面序号11： 1

页面序号12： 5

页面序号13： 0

输入结束！

置换情况如下：

发生缺页中断，但内存中有空闲区，4号页面直接调入！400

发生缺页中断，但内存中有空闲区，3号页面直接调入！430

发生缺页中断，但内存中有空闲区，2号页面直接调入！432

发生缺页中断，将4号页面调出，1号装入！321

发生缺页中断，将3号页面调出，4号装入！214

发生缺页中断，将2号页面调出，3号装入！143

发生缺页中断，将1号页面调出，5号装入！435

内存中有4号页面，无须缺页中断！435

内存中有3号页面，无须缺页中断！435

发生缺页中断，将5号页面调出，2号装入！432

发生缺页中断，将4号页面调出，1号装入！321

发生缺页中断，将3号页面调出，5号装入！215

页号12个，缺页中断10次，缺页率：83.3333%

调试二：

请输入存储区块数：4

请输入页号走向（输入0结束）：

页面序号1： 4

页面序号2： 3

页面序号3： 2

页面序号4： 1

页面序号5： 4

页面序号6： 3

页面序号7： 5

页面序号8： 4

页面序号9： 3

页面序号10： 2

页面序号11： 1

页面序号12： 5

页面序号13： 0

输入结束！

置换情况如下：

发生缺页中断，但内存中有空闲区，4号页面直接调入！

发生缺页中断，但内存中有空闲区，3号页面直接调入！

发生缺页中断，但内存中有空闲区，2号页面直接调入！

发生缺页中断，但内存中有空闲区，1号页面直接调入！

内存中有4号页面，无须缺页中断！

内存中有3号页面，无须缺页中断！

发生缺页中断，将2号页面调出，5号装入！

内存中有4号页面，无须缺页中断！

内存中有3号页面，无须缺页中断！

发生缺页中断，将3号页面调出，2号装入！

发生缺页中断，将5号页面调出，1号装入！

发生缺页中断，将4号页面调出，5号装入！

页号12个，缺页中断8次，缺页率：66.6667%

_Domineering
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lfu算法实现java_LFU五种实现方式，从简单到复杂
weixin_34908663的博客
02-23 506
前言最近刷力扣题，对于我这种 0 基础来说，真的是脑壳疼啊。这个月我估计都是中等和困难题，没有简单题了。幸好，力扣上有各种大牛给写题解。看着他们行云流水的代码，真的是羡慕不已。让我印象最深刻的就是人称 “甜姨” 的知心姐姐，还有名叫威哥的大哥。几乎每天他们的题解我都是必看的。甜姨的题解，虽然姿势很帅，但是对于我这种新手来说，感觉不是太友好，因为思路写的太少，不是很详细。所以，每次我看不明白的时候，...
操作系统课程设计页面置换算法模拟（javaweb+数据库+多线程+AJAX动态体现+柱状图对比）
最新发布
07-09
本文利用javaweb，连接了数据库，主要实现了五种置换算法、随机数生成、多线程启动和暂停、动画显示实现、柱状图生成、查看历史纪录、只显示最新一次结果等功能。 具体如下： 实现了五种置换算法，OPT、CLOCK、LFU、...
操作系统FIFO，LRU，LFU算法
12-26
实现了操作系统中的FIFO，LRU，LFU页面置换算法，能够动态输入物理块以及页面数，得出每一步的置换步骤以及置换率，简单有效。
2021-11-07数据结构LUF代码案例
m0_52568673的博客
11-07 179
LUF代码 也有感到过无能为力，但每时每刻都在等风来，卷起我燃烧的灵魂，吹灭我身上的火焰，带我逃离喧嚣的人间，奔赴自由与浪漫。 ```java class LFUCache { // key 到 val 的映射，我们后文称为 KV 表 HashMap<Integer, Integer> keyToVal; // key 到 freq 的映射，我们后文称为 KF 表 HashMap<Integer, Integer> keyToFreq; //
最不经常使用LFU（least frequently used）算法java实现
Boush
01-09 1274
LFU（least frequently used）最不经常使用算法 java实现
java实现LFU
weixin_43831204的博客
10-08 299
public class LFU<k, v> { private final int capcity; private Map<k, v> cache = new HashMap<>(); private Map<k, HitRate> count = new HashMap<>(); public LFU(int capcity) { this.capcity = capcity; } public voi
操作系统课程设计——页面置换算法模拟实现
02-24
设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰算法（OPT），最近最久未使用算法（LRU）计算不同内存容量下的缺页率，模拟表示出不同算法内存中页面的变化情况，并对不同内存容量下...
操作系统页面置换算法实现，fifo、lfu、lru、opt，界面由MFC实现
03-28
本项目实现了一个模拟器，用于演示和比较四种不同的页面置换算法：FIFO（先进先出）、LFU（最不常用）、LRU（最近最少使用）以及OPT（最佳页面置换）。界面使用Microsoft Foundation Class (MFC)库来创建，使得用户...
操作系统课程设计之页面置换算法（流程模拟）
12-22
3. **页面置换算法**：常见的页面置换算法有多种，如FIFO（先进先出）、LRU（最近最少使用）、LFU（最不经常使用）、OPT（最佳页面置换）等。这些算法的目标是在有限的内存资源下，尽可能减少因页面缺失（Page Fault...
页面置换算法是操作系统中用于管理虚拟内存的一种重要算法
05-30
常见的页面置换算法包括最佳置换算法（Optimal Replacement Algorithm）、先进先出算法（First-In-First-Out, FIFO）、最近最少使用算法（Least Recently Used, LRU）、最少使用算法（Least Frequently Used, LFU）...
LFU算法LFU算法LFU算法LFU算法
12-13
LFU算法LFU算法LFU算法LFU算法LFU算法
LFU算法的Java代码实现
BASK2311的博客
04-28 472
算法基础解释，已经会的可以直接跳过哈。LFU是最近不经常使用算法。听到这个名字，就问你迷糊不？还有个类似的叫LRU算法，叫最近最少使用算法。它的代码实现，本人实现了一波，有兴趣可以看下：好了，两者的应用场景基本一致，大多数都是缓存。本质上就是当我缓存的地方满了，现在又要添新的值，需要舍弃哪个旧值？LRU就是舍弃缓存数据中最后一次访问时间最早的数据。（注重时间）LFU即使舍弃访问次数最少的数据中最后一次访问时间最少的数据（注重次数+时间）什么？你还不懂？那我可要举例子了。复制代码。
LFU
gkq_tt的博客
01-19 532
设计并实现一个数据结构，满足LFU (Least Frequently Used) Cache特性，实现两种操作：get和put get(key)：返回指定key对应的value，如果指定key在cache中不存在，返回-1 put(key, value)：设置指定key的value，如果key不存在，则插入该key-value对。如果cache空间已满，则将最少使用的key-value对移除，...
LFU cache Java
a33b33C33的专栏
07-24 656
public class LFUCache {     HashMap hashtable = new HashMap();     int column;     PriorityQueue priorityQueue;          public LFUCache(int capacity) {         column = capacity;         KeyVa
用Java撸一下LFU简易版本
热门推荐
weixin_43272605的博客
02-19 2万+
最近在别人文章看到一片关于LFU的题目，个人觉得实现可以不同，他用的c，那我用java写一下，毕竟c已经忘的差不多了。 那个题就是让我们来设计一个数据结构，使其能够按照key-value的方式来实现put和get，而且要满足LFU，而且在空间满了之后，又要满足最近最少使用即LRU，且操作时间复杂度要满足O(1) 首先看看什么是LFU LFU(Leatest Frequently Used)即访问频...
lfu java_LFU - 猫熊小才天 - 博客园
weixin_32153867的博客
02-27 100
date: 2020-12-08 10:49:21updated: 2020-12-08 14:57:09LFULFU(Least Frequently Used ，最近最少使用算法)算法描述：class LFUCache {// 构造容量为 capacity 的缓存public LFUCache(int capacity) {}// 在缓存中查询 keypublic int get(int ke...
LFU算法
m0_46388866的博客
02-14 1219
LFU算法 （向labuladong老师学习的LFU） LFU算法是什么？有什么作用？ LFU算法其实就是按照程序使用的次数频率来进行淘汰的算法，使用频率少就会被删除。它在程序过多的情况下，是一种很好的处理策略。 那么LFU算法是如何实现的？ LFU算法是比较复杂的，因为数据结构偏多，需要处理不只是一个数据结构，而是多个，所以容易忽略和写错。最好的办法就是从大看小，先把方法写出来，画出图，然后整理大逻辑，最后再落脚在小的细节上面。现在来从大体来说说它是如何实现的。 freq：就是使用程序多少次的意思 ①第一
最近最少使用LRU算法，最不常用LFU算法，分段SLRU算法
04-27
LRU算法是Least Recently Used的缩写，最近最少使用算法。它是一种常用的页面置换算法，根据页面历史访问记录来进行页面置换。当缓存满时，会将最久未使用的页面置换掉。 LFU算法是Least Frequently Used的缩写，最不常用算法。它是一种根据页面访问频率来进行页面置换的算法。当缓存满时，会将访问次数最少的页面置换掉。 分段SLRU算法是一种结合了LRU和LFU算法的页面置换算法。它将缓存分为热数据段和冷数据段，对于热数据段使用LRU算法进行页面置换，对于冷数据段使用LFU算法进行页面置换。 需要注意的是，不同的应用场景适合使用不同的页面置换算法，无法一概而论哪种算法更好。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值