页面置换算法（FIFO，LRU，OPT，LRF）

最新推荐文章于 2023-07-10 10:26:59 发布
最新推荐文章于 2023-07-10 10:26:59 发布
阅读量642 收藏
点赞数
文章标签： java ui
原文链接：http://www.cnblogs.com/cky-2907183182/p/10822331.html
版权

import java.util.Random;
import java.util.LinkedList;
import java.util.Scanner;
public class Manage {
    public static int[] getOrder(){
        int[] a = new int[320];
        a[319] = -1;
        Random ran = new Random();
        int count = -1;
        try {
            while(a[319] < 0) {
                int m = ran.nextInt(320);               
                a[++count] = m+1;                    //在0-320生成随机数    
                int m1 = ran.nextInt(m+2);
                a[++count] = m1;
                a[++count] = m1+1;
                a[++count] = ran.nextInt(318-m1)+m1+2;
            }
        }catch(IllegalArgumentException e) {
            
        }
        return a;
    }
    
    public static int[] getAddress(int[] a) {        //获得每个指令对应的页面
        int[] b = new int[320];
        for(int i = 0;i < 320;i++) {
            b[i] = a[i]/10;
        }
        return b;
    }
    
    public static int FIFO(int num,int[] b) {
        LinkedList<Integer> list = new LinkedList<Integer>();   //作为物理块
        int count = 0;
        for(int i = 0;i < 320;i++) {
            if(list.contains(b[i])){                            //如果物理块已包含该页面，进行下一次判断
                continue;
            }else if(list.size() < num && !list.contains(b[i])){//物理块不包含该页面而且物理块未满
                list.add(b[i]);                                    //装入页面
                count++;                                        //缺页次数加一
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }else if(list.size() >= num && !list.contains(b[i])){//物理块不包含该页面而且物理块已满
                list.poll();                                     //移出队首元素
                list.add(b[i]);                                     //装入页面
                count++;                                         //缺页次数加一
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }
        }
        return count;
    }
    
    
    public static int LRU(int num,int[] b) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        int count = 0;
        for(int i = 0;i < 320;i++) {                
            if(list.contains(b[i])){                
                list.remove(list.indexOf(b[i]));    //如果物理块中已包含该页面，就把该页面移到队尾，保证队首元素是最近最久未使用的
                list.add(b[i]);
            }else if(list.size() < num && !list.contains(b[i])){//物理块不包含该页面而且物理块未满
                list.add(b[i]);
                count++;
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }else if(list.size() >= num && !list.contains(b[i])){//物理块不包含该页面而且物理块已满
                list.poll();
                list.add(b[i]);
                count++;
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }
        }
        return count;
    }
    
    public static int OPT(int num,int[] b) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        LinkedList<Integer> list2 = new LinkedList<Integer>();   //用于记录数据是否在list中重复出现
        int index = 0;
        int count = 0;                                            //记录换页次数
        for(int i = 0;i < 320;i++) {
            if(list.contains(b[i])){                            //如果物理块中已包含该页面
                continue;
            }else if(list.size() < num && !list.contains(b[i])){ //物理块不包含该页面而且物理块未满
                list.add(b[i]);
                count++;                                            
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }else if(list.size() >= num && !list.contains(b[i])){     //物理块不包含该页面而且物理块已满                                          //用来确定需被移除页面在list中的下标
                for(int a = i+1;a < 320;a++) {                    
                    if(list2.size() < list.size()) {            
                        if(list.contains(b[a]) && !list2.contains(b[a])) {//确定list中的页面没有被重复扫描
                            list2.add(b[a]);
                            index = list.indexOf(b[a]);                      //记录被移除元素下标
                        }
                    }else{
                        list2.clear();                                        //重置list2
                        break;
                    }
                }
                list.remove(index);
                list.add(b[i]);
                count++;
                index = 0;
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }
        }
        return count;
    }
    
    
    public static int LFR(int num,int[] b) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        int index = 0;
        int[] count2 = new int[num];                        //用于给页面使用次数做记录
        for(int z = 0;z < count2.length;z++) {
            count2[z] = 0;
        }
        int count = 0;
        for(int i = 0;i < 320;i++) {
            if(list.contains(b[i])){                        //如果物理块中已包含该页面
                continue;
            }else if(list.size() < num && !list.contains(b[i])){//物理块不包含该页面而且物理块未满
                list.add(b[i]);
                count++;
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }else if(list.size() >= num && !list.contains(b[i])){//物理块不包含该页面而且物理块已满
                for(int a = 0;a < num;a++) {                        
                    for(int c = i-1;c >= 0 ;c--) {
                        if(i-c <= 30) {                                //观察前30次调用
                            if(b[c] == list.get(a)) {                //30次内被调用过一次，标志该页面的值加一，做记录
                                count2[a]++;
                            }
                        }else {
                            break;
                        }
                    }
                }                
                int min = count2[0];                //取出最小值下标，即使用次数最少的页数
                for(int y = 0;y < count2.length;y++) {
                    if(count2[y] < min) {
                        min = count2[y];
                        index = y;
                    }
                }
                for(int z = 0;z < count2.length;z++) {//重置count2数组
                    count2[z] = 0;
                }
                list.remove(index);
                list.add(b[i]);                            //重置index
                index = 0;
                count++;
                for(Integer l: list) {
                    System.out.print(l+"\t");
                }
                System.out.println();
            }
        }
        return count;
    }
    
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] a = getOrder();
        System.out.println("随机生成的指令：");
        for(int i = 0;i<320;i++) {
            System.out.print(a[i]+"\t");
            if((i+1)%10 == 0) {
                System.out.println();
            }
        }
        System.out.println("=======================================================================");
        int[] b = getAddress(a);
        System.out.println("形成的地址页号：");
        for(int i = 0;i<320;i++) {
            System.out.print(b[i]+"\t");
            if((i+1)%10 == 0) {
                System.out.println();
            }
        }
        System.out.println("=======================================================================");
        System.out.println("输入物理块数：");
        int blocks = sc.nextInt();
        System.out.println("选择算法："+"\n"+"1:FIFO"+"\n"+"2:LRU"+"\n"+"3:OPT"+"\n"+"4:LFR");
        int algo = sc.nextInt();
        switch(algo)
        {
        case 1:
            int count1 = 320 - FIFO(blocks,b);            //命中次数=320 - 缺页次数
            double rate1 = (double)count1/320;
            System.out.println("命中次数："+count1);
            System.out.println("命中率："+rate1);
            break;
        case 2:
            int count2 = 320 - LRU(blocks,b);
            double rate2 = (double)count2/320;
            System.out.println("命中次数："+count2);
            System.out.println("命中率："+rate2);
            break;
        case 3:
            int count3 = 320 - OPT(blocks,b);
            double rate3 = (double)count3/320;
            System.out.println("命中次数："+count3);
            System.out.println("命中率："+rate3);
            break;
        case 4:
            int count4 = 320 - LFR(blocks,b);
            double rate4 = (double)count4/320;
            System.out.println("命中次数："+count4);
            System.out.println("命中率："+rate4);
            break;
        default:
            System.out.println("输入错误！");
                
        }
        sc.close();
    }
}

转载于:https://www.cnblogs.com/cky-2907183182/p/10822331.html

weixin_30634661
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
本课程设计项目专注于两种常见的页面置换算法：FIFO（先进先出）和LRU（最近最少使用）。这两种算法都是为了在主存空间不足时决定哪些页面应该被换出到磁盘，以便腾出空间加载新的页面。 **FIFO页面置换算法**： ...
【Practice Daily】LRF算法题解
I'm Zz.
08-01 201
460.LFU缓存 struct Node { int cnt, time, key, value; Node(int _cnt, int _time, int _key, int _value):cnt(_cnt), time(_time), key(_key), value(_value){} bool operator < (const Node& rhs) const { return cnt == rhs.cnt ? time &l
如何实现LRU缓存淘汰算法
calm_encode的博客
10-01 498
数组简单易用，在实现上使用的是连续的内存空间，可以借助CPU的缓存机制，预读数组中的数据，所以访问效率比较高。而链表在内存中并不是连续存储，所以对CPU缓存不友好，没办法有效于预读。 数组的缺点是大小固定，一经声明就要占用整块连续内存空间。如果声明的数组过大，系统可能没有足够的连续内存分配给它，导致"内存不足（out of memory）"。如果声明的数组过小，则可能出现不够用的情况。这时只能再申请一个更大的内存空间，把原来数组拷贝进去，非常耗时。链表本身没有大小的限制，天然地支持动态扩容，我觉得这也是它
redis总结
Sober1894的博客
04-26 980
redis知识点总结
LRF-（详细通俗易懂）Java 实现 斗地主 案例 实现有序
weixin_51749554的博客
02-09 2098
上次已经介绍了Java实现斗地主案例到手的牌无序斗地主到手牌无序的案例，这次分享Java实现斗地主到手牌有序的实现。 斗地主案例实现步骤 分析： 首先来梳理一下规则： （1）准备牌阶段：斗地主总共54张牌，大王小王各一张（特殊对待），其他52张牌，分别4种花色，每种花色13张。四种花色分别为♥ ♦ ♠ ♣；每一种花色中的13张牌（由大到小）2 A K Q J 10 9 8 7 6 5 4 3，定义Map集合进行存储牌的索引和组装好的牌，循环遍历两个集合组装52张牌；如：♥ 7，♠ 8等； (2)洗牌阶段：使
Redis 的 LRU 与 LFU 算法实现
最新发布
每天都要开心呀(#^.^#)
07-10 1413
重点介绍了 Redis 的 LRU 与 LFU 算法实现，并分析总结了两种算法的实现效果以及存在的问题。
JAVA实现FIFO、LRU、OPT页面置换算法，有界面
06-28
本项目涉及到了三种经典的页面置换算法：FIFO（先进先出）、LRU（最近最久未使用）以及OPT（最佳页面置换）。这些算法在JAVA环境下实现，并且具备用户界面，便于理解和学习。 1. FIFO（先进先出）页面置换算法： ...
页面置换算法（OPT、FIFO、LRU）实现--C++版本-页面置换算法（Optimal、FIFO、LRU）
12-18
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面...
置换算法OPT，FIFO，LRU
10-28
随机给出一个页面执行序列，如：1,5,3,4,2,1,3,4,5,7,9,……。要求计算以下几种置换算法的...最佳置换算法OPT（Optimal） 先进先出算法FIFO（First In First Out） 最近最少使用算法LRU（Least Recently Used）
FIFO、OPT、LRU页面置换算法实验代码和截图
12-24
FIFO、OPT、LRU页面置换算法实验代码和截图 在操作系统中，页面置换算法是指操作系统在内存不足时，如何将某些页面从内存中移除，以腾出空间供其他页面使用的算法。常见的页面置换算法有FIFO、OPT、LRU等。 FIFO...
页面置换六种算法c语言实现
01-02
opt、FIFO、LRU/LFU、简单clock、改进型clock等算法实现页面置换
常用缓存淘汰算法（LFU、LRU、ARC、FIFO、MRU）
Java技术栈，分享最主流的Java技术
01-06 2万+
缓存算法是指令的一个明细表，用于决定缓存系统中哪些数据应该被删去。 常见类型包括LFU、LRU、ARC、FIFO、MRU。 最不经常使用算法（LFU）： 这个缓存算法使用一个计数器来记录条目被访问的频率。通过使用LFU缓存算法，最低访问数的条目首先被移除。这个方法并不经常使用，因为它无法对一个拥有最初高访问率之后长时间没有被访问的条目缓存负责。 最近最少使用算法（LRU）： 这个缓存
全面讲解LRU算法
Apple_Boy的博客
11-09 10万+
文章目录概念理解LRU原理基于 HashMap 和 双向链表实现 LRU 的Redis的LRU实现实际运用 概念理解 1.LRU是Least Recently Used的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的，是根据页面调入内存后的使用情况进行决策了。由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU算法就是将最近最久未使用的页面予...
LFU算法
Searcher_Recommeder的博客
03-30 1万+
1，基本原理LFU（Least Frequently Used）算法根据数据的历史访问频率来淘汰数据，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。LFU的每个数据块都有一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。具体实现如下： 1. 新加入数据插入到队列尾部（因为引用计数为1）；2. 队列中的数据被访问后，引用计数增加，队列重新排序；3...
LRU算法四种实现方式介绍
热门推荐
elricboa的专栏
12-19 20万+
LRU全称是Least Recently Used，即最近最久未使用的意思。 LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 实现LRU       1.用一个数组来存储数据，给每一个数据项标记一个访问时间戳，每次插入新数据项的时候，先把数组中存
LR算法(基础及核心概念)
buracag_mc的博客
08-27 5万+
前言首先需要清楚的是，LR（Logistic Regression）虽然是回归模型，但却是经典的分类方法。 为什么分类不用SVM呢？我们对比一下SVM，在二分类问题中，如果你问SVM，它只会回答你该样本是正类还是负类；而你如果问LR，它则会回答你该样本是正类的概率是多少~ 文章主要内容如下： LR的理论基础 LR的参数求解过程 正则化
RF（随机森林）算法原理及其派生算法
沈春旭的博客
05-20 2万+
1.前言 集成学习有两个流派，一个是boosting派系，它的特点是各个弱学习器之间有依赖关系。另一种是bagging流派，它的特点是各个弱学习器之间没有依赖关系，可以并行拟合。本文就对集成学习中Bagging与随机森林算法做一个总结。 随机森林是集成学习中可以和梯度提升树GBDT分庭抗礼的算法，尤其是它可以很方便的并行训练，在如今大数据大样本的的时代很有诱惑力。 2.bag
缓存淘汰算法--LRU算法(java代码实现)
long的博客
04-14 5万+
LRU 缓存 算法
LRU算法及例题讲解
xiao_Mrs_li的博客
04-05 4万+
概念： LRU（least recently used)是将近期最不会访问的数据给淘汰掉，其实LRU是认为最近被使用过的数据，那么将来被访问的概率也多，最近没有被访问，那么将来被访问的概率也比较低“，其实这个并不是正确的，但是因为LRU算法简单，存储空间没有被浪费，所以还是用的比较广泛的。 LRU原理： LRU一般采用链表的放缓死实现，便于快速移动数据位置。网
页面置换算法FIFO、OPT、LRU的缺页率区别分析
05-25
2. OPT算法：OPT算法是一种理论上最优的页面置换算法，它能够找到未来最长时间内不再被访问的页面进行淘汰。但是，由于需要预测未来访问情况，实现较为困难。缺页率通常较低，是三种算法中最低的。 3. LRU算法：LRU...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值