页面置换算法（FIFO,LRU)

最新推荐文章于 2022-02-27 02:42:29 发布
最新推荐文章于 2022-02-27 02:42:29 发布
阅读量1.3k 收藏 1
点赞数 4
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46708851/article/details/121552244
版权

目录

FLFO（内存块3）

 FLFO（内存块4）

LRU（内存块4）

主函数

FLFO（内存块3）

 FLFO（内存块4）

算法实现（java实现）（复制时注意添加主函数）

static void first_in_first_out(int amount, int[] page, int memory_block) {
        int[][] memory = new int[memory_block][amount];
        String[] page_missing = new String[amount];
        int i1 = memory_block;
        for (int i = 0; i < memory_block; i++) {
            for (int j = 0; j < memory_block; j++) {
                if (j >= i) {
                    memory[i][j] = page[i];
                } else {
                    memory[i][j] = -1;
                }
            }
            page_missing[i] = "缺页";
        }
        for (int i = memory_block; i < amount; i++) {
            int num = i1 % memory_block;
            int count = 0;
            for (int j = 0; j < memory_block; j++) {
                if (memory[j][i - 1] == page[i]) {
                    count = 1;
                    break;
                }
                if (memory[j][i - 1] == -1 && i > memory_block) {
                    int control = i - 1;
                    while (memory[j][control] == -1) {
                        control--;

                    }
                    if (memory[j][control] == page[i]) {
                        count = 1;
                        break;
                    }
                }
            }
            if (count == 0) {
                for (int k = 0; k < memory_block; k++) {
                    if (memory[k][i - 1] != -1) {
                        memory[k][i] = memory[k][i - 1];
                    } else {
                        for (int j = i - 1; j > 0; j--) {
                            if (memory[k][j] != -1) {
                                memory[k][i] = memory[k][j];
                                break;
                            }
                        }
                    }
                }
                memory[num][i] = page[i];
                i1++;
                page_missing[i] = "缺页";
            }
            if (count == 1) {
                for (int j = 0; j < memory_block; j++) {
                    memory[j][i] = -1;
                }
                page_missing[i] = "不缺页";
            }
        }
        System.out.print("访问页面" + "\t");
        for (int k = 0; k < amount; k++) {
            System.out.print(page[k] + " ");
        }
        System.out.println(" ");
        for (int i = 0; i < memory_block; i++) {
            for (int k = 0; k < amount; k++) {

                System.out.print(memory[i][k] + " ");
            }
            System.out.println("");

        }
        System.out.print("是否缺页" + "\t");
        for (int k = 0; k < amount; k++) {
            System.out.print(page_missing[k] + " ");
        }
    }

运行结果（内存块3）（-1表示null）

先进先出置换算法
访问页面    3 2 1 0 3 2 4 3 2 1 0 4  
3 3 3 0 0 0 4 -1 -1 4 4 -1 
-1 2 2 2 3 3 3 -1 -1 1 1 -1 
-1 -1 1 1 1 2 2 -1 -1 2 0 -1 
是否缺页    缺页 缺页 缺页 缺页 缺页 缺页 缺页 不缺页 不缺页 缺页 缺页 不缺页 


Process finished with exit code 0

运行结果（内存块4）（-1表示null）

先进先出置换算法
访问页面    3 2 1 0 3 2 4 3 2 1 0 4  
3 3 3 3 -1 -1 4 4 4 4 0 0 
-1 2 2 2 -1 -1 2 3 3 3 3 4 
-1 -1 1 1 -1 -1 1 1 2 2 2 2 
-1 -1 -1 0 -1 -1 0 0 0 1 1 1 
是否缺页    缺页 缺页 缺页 缺页 不缺页 不缺页 缺页 缺页 缺页 缺页 缺页 缺页 


Process finished with exit code 0

LRU（内存块4）

算法实现（java实现）（复制时注意添加主函数）

static void last_unused(int amount, int[] page, int memory_block) {
        int[][] memory = new int[memory_block][amount];
        String[] page_missing = new String[amount];
        int[] list = new int[memory_block];
        int[] list1 = new int[memory_block];
        memory[0][0] = page[0];
        list[0] = page[0];
        page_missing[0] = "缺页";
        int count = 0;
        int count1 = 1;
        int number = 0;
        for (int i = 1; i < memory_block; i++) {
            memory[i][0] = -1;
            list[i] = -1;
        }

        for (int i = 1; i < amount; i++) {
            count = 0;
            for (int j = 0; j < memory_block; j++) {
                if(page[i] == list[j]){
                    count = 1;
                }
            }
            if (count == 1){

                for (int j = 0; j < memory_block; j++) {
                    memory[j][i] = -1;
                }
                page_missing[i] = "不缺页";
            }
            if(count == 0){
                list[count1] = page[i];
                count1++;
                for (int j = 0; j < memory_block; j++) {
                    memory[j][i] = list[j];
                }
                page_missing[i] = "缺页";
            }
            if (list[memory_block-1] != -1){
                number = i;
                break;
            }
        }



        for (int i = number+1; i < amount; i++) {
            count = 0;
            number = 0;
            for (int j = 0; j < memory_block; j++) {
                list1[j] = list[j];
            }
            for (int j = 0; j < memory_block; j++) {
                if(list[j] == page[i]){
                    count = 1;
                    break;
                }
            }
            if (count == 1){

                for (int j = 0; j < memory_block; j++) {
                    memory[j][i] = -1;
                }
                page_missing[i] = "不缺页";
            }
            if(count == 0){
                for (int j = i-1; j >= 0 ; j--) {
                    for (int k = 0; k < memory_block; k++) {
                        if (list1[k] == page[j]){
                            list1[k] = -1;
                            number++;
                        }
                        if (number == memory_block){

                            list[k] = page[i];
                            break;
                        }
                    }
                    if (number == memory_block){
                        break;
                    }
                }
                for (int j = 0; j < memory_block; j++) {
                    memory[j][i] = list[j];
                }
                page_missing[i] = "缺页";
            }
        }


        System.out.print("访问页面" + "\t");
        for (int k = 0; k < amount; k++) {
            System.out.print(page[k] + " ");
        }
        System.out.println(" ");
        for (int i = 0; i < memory_block; i++) {
            for (int k = 0; k < amount; k++) {

                System.out.print(memory[i][k] + " ");
            }
            System.out.println("");

        }
        System.out.print("是否缺页" + "\t");
        for (int k = 0; k < amount; k++) {
            System.out.print(page_missing[k] + " ");
        }
    }

运行结果（内存块4）（-1表示null）

最近最久未用置换算法
访问页面    1 8 1 7 8 2 7 2 1 8 3 8 2 1 3 1 7 1 3 7  
1 1 -1 1 -1 1 -1 -1 -1 -1 1 -1 -1 -1 -1 -1 1 -1 -1 -1 
-1 8 -1 8 -1 8 -1 -1 -1 -1 8 -1 -1 -1 -1 -1 7 -1 -1 -1 
-1 -1 -1 7 -1 7 -1 -1 -1 -1 3 -1 -1 -1 -1 -1 3 -1 -1 -1 
-1 -1 -1 -1 -1 2 -1 -1 -1 -1 2 -1 -1 -1 -1 -1 2 -1 -1 -1 
是否缺页    缺页 缺页 不缺页 缺页 不缺页 缺页 不缺页 不缺页 不缺页 不缺页 缺页 不缺页 不缺页 不缺页 不缺页 不缺页 缺页 不缺页 不缺页 不缺页 


Process finished with exit code 0

主函数

注释部分为自由输入（也可以选择非注释部分代码块里面输入）

import java.util.Scanner;
//置换算法
public class replacement {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
    /*    System.out.println("请输入待访问页面数量");
        int amount = scanner.nextInt();
        System.out.println("请输入需要访问的访问页面");
        int[] page = new int[amount];
        for (int i = 0; i < amount; i++) {
            page[i] = scanner.nextInt();
        }
        System.out.println("请输入内存块大小");
        int memory_block = scanner.nextInt();*/
        int amount = 20;

        int[] page = new int[]{1,8,1,7,8,2,7,2,1,8,3,8,2,1,3,1,7,1,3,7};
        int memory_block = 4;
        System.out.println("先进先出置换算法");
        first_in_first_out(amount, page, memory_block);

        System.out.println("\n最近最久未用置换算法");
        last_unused(amount, page, memory_block);
    }
}

补充：图片来源于王道考研-操作系统

西科胡先生
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
页面置换算法三种(LRU OPT FIFO)
11-14
掌握内存管理的页面淘汰算法 输入可用内存页面数和一个作业访问逻辑页号的序列，分别给存FIFO、LRU算法的缺页中断率 LRU OPT FIFO
页面置换算法（OPT、FIFO、LRU）实现--C++版本
09-15
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面的状况 3、时间的流逝可用下面几种方法模拟：按键盘，每按一次可认为过一个时间单位; 4、将一批页的置换情况存入磁盘文件，以后可以读出并重放; 5、计算页面的缺页次数、缺页后的页面置换次数 6、支持算法：FIFO、LRU、最佳置换算法。
页面置换算法--FIFO(操作系统)
asdbkaj的博客
12-28 4461
页面置换算法–FIFO 先初始化页面大小，和物理块数。连续输入页面的逻辑地址，以“-1”作为结束标志，采用FIFO页面置换算法、固定分配局部置换分配策略。输出该页面的页号和页内位移，若该页不在内存，并且还有剩余的物理块，将该页调入内存，输出“该页不在内存中,调入!”输出当前在内存的物理块号和对应的页号（若当前物理块为空，则输出void）；若该页不在内存，并且没有剩余的物理块，按照FIFO算法选择一页调出后将该页调入内存，输出“已无空闲物理块,置换!”并输出当前在内存的物理块号和对应的页号（若当前物理块为空，
操作系统——FIFO和LRU页面置换算法
热门推荐
u012321457的博客
06-16 5万+
一、算法介绍1. 先进先出FIFO页面置换算法（来自百度百科-先进先出页面置换算法）简介：优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。实现过程：假定系统为某进程分配了三个物理块，并考虑有以下页面号引用串：7, 0, 1,...
FIFO, LRU, OPT 页面置换算法
jinian_08的专栏
05-27 4659
#include #include #define row 3 #define col 20 int Pagein[col]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1}; int Output[row][col]; struct Memory{     int num;     int time; }; struct Memory memory[row]; void Init(){     int i;     for(i=0; i    
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
这是一个自己完成软件工程的操作系统课程课程设计题目：此程序用于模拟虚拟磁盘页面置换算法，实现了FIFO页面置换算法和LRU页面置换算法，获得课程设计优秀的好成绩
页面置换算法（OPT、FIFO、LRU）实现--C++版本-页面置换算法（Optimal、FIFO、LRU）
12-18
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面...
页面置换算法最佳，FIFO，LRU，随机，简单CLOCK,改进CLOCK.zip
02-24
一个页面置换算法性能比较程序，包括了最佳置换，先进先出，LRU，随机置换，简单时钟和改进时钟六个算法。使用了队列，链表，循环链表等数据结构。随机产生请求页号，计算六种算法的缺页率。
页面置换算法FIFO LRU OPT
01-04
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率： 要求设计主界面以灵活选择某算法，且以下算法都要实现 1、先进先出算法（FIFO） ...3、最佳置换算法（OPT）
页面置换算法 FIFO NUR LRU LFU.docx
06-27
。。。
模拟实现FIFO和LRU页面置换算法
06-15
模拟实现FIFO和LRU页面置换算法：代码
页面置换算法（FIFO算法，LRU算法）
10-20
关于操作系统的页面置换算法，包括FIFO算法，LRU算法，程序，流程图
页面置换算法(FIFO,LRU,OPT)
12-11
常用的几种页面置换算法,运用数组结构实现页面置换的FIFO,LRU,OPT算法
【基础算法 三】LRU 和 FIFO 页面置换算法
MaoLin Tian's Blog
09-19 2849
转自http://blog.csdn.net/u013575812/article/details/50976482 内存里边没有该最新访问的页面就叫做缺页，如果有就叫做命中 内存满的时候之前的页面被挤出去的现象叫一次缺页中断 在一个采用页式虚拟存储管理的系统中，有一用户作业，它依次要访问的序列是1，2，3，4，1，2，5，1，2，3，4，5.假定分配给该作业的页数为3且作业初始时
页面置换算法之 FIFO算法
零碎@流年絮语 的博客
12-05 3226
先进先出置换算法（FIFO） 最简单的页面置换算法，淘汰最先调入的。 实现：队列 依据: 先进入的可能已经使用完毕。 基本思想： 当需要淘汰一个页面时，总是选择驻留主存时间最长的页面进行淘汰，即先进入主存的页面先淘汰。 理由： 最早调入主存的页面不再被使用的可能性最大。 即优先淘汰最早进入内存的页面。（往前看） 说明： 该算法的出发点是最早调入内存的页面，其不再被访问的可能性会大一些。 该算法实现比较简单，对具有线性顺序访问的程序比较合适，而对其他情况效率不高。因为经常被访问的页面，往往在内存中停留最久，
LRU和LFU 算法（页面置换算法）
热爱学习和钻研。
02-27 3万+
LRU和LFU的区别 LRU和LFU都是内存管理的页面置换算法。 LRU：最近最少使用(最长时间)淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的页面。 LFU：最不经常使用(最少次)淘汰算法（Least Frequently Used）。LFU是淘汰一段时间内，使用次数最少的页面。 例子 假设LFU方法的时期T为10分钟，访问如下页面所花的时间正好为10分钟，内存块大小为3。若所需页面顺序依次如下： 2 1 2 1 2 3 4 ----------
FIFO页面置换算法
weixin_34367845的博客
06-23 93
本文以序列长度20的{ 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};以及页面4；为例； 1 #include <stdio.h> 2 3 #define InitPysiBlocks 4 4 #define MaxPages 20 5 int PysicalBlocks[InitPysiBlocks] = { -1,-1,...
页面置换算法 FIFO NUR LRU LFU
admin_2015的博客
06-21 1196
计算用LRU和FIFO算法计算“缺页率”。 http://www.docin.com/p-102712160.html http://wenku.baidu.com/view/4f3e9cf1f61fb7360b4c65fb.html 在一个虚拟存储管理系统中，假如系统分配给一个作业的内存物理块数是3，并且此作业的页面使用顺序为2，3，2，1，5，2，4，5，3，2，5，2，若...
页面置换算法-LFU
qq_33696779的博客
03-13 3726
LFU（Least Frequently Used）,表示最近使用次数最少来进行淘汰，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。其相关也有好几种不同的LFU算法，主要有LFU*、LFU-Aging、LFU*-Aging、Window-LFU等。 LFU中的每条数据都需要记录一个访问次数，所有的数据按照访问次数排序，当缓存存满时在插入数...
页面置换算法opt fifo lru
最新发布
06-06
b'\xe9\xa1\xb5\xe9\x9d\xa2\xe7\xbd\xae\xe6\x8d\xa2\xe7\xae\x97\xe6\xb3\x95opt fifo lru'的意思是“页面置换算法opt fifo lru”。这是在操作系统中用来管理内存的算法，用于决定哪些页应该被从内存中交换出去，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值