LRU算法模拟器（基于Java和VUE前端实现）

最新推荐文章于 2024-04-10 15:26:27 发布
最新推荐文章于 2024-04-10 15:26:27 发布
阅读量265 收藏 1
点赞数
分类专栏： 笔记 文章标签： javascript LRU算法 前端 vue.js java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45928161/article/details/127515841
版权

目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

一、核心思路

在这里插入图片描述

在这里插入图片描述

二、代码源码

<template>

    <el-form
            :label-position="right"
            label-width="100px"
            :model="this.formData"
            style="max-width: 460px;"
            class="labelStyle"
    >
        <el-form-item label="执行页面序列">
            <el-input v-model="this.formData.pages" placeholder="输入页面以英文逗号分隔" />
        </el-form-item>
        <el-form-item label="物理块数" >
            <p>
                <el-input-number v-model="this.formData.blcoks" :min="1" :max="10"/>
            </p>
            <p style="margin-left: 10px">
                <el-button @click="LRU">运行</el-button>
            </p>
        </el-form-item>
        <el-form-item label="缺页中断次数:">
            <p style="color: white">{{this.formData.missNum}}</p>
        </el-form-item>
    </el-form>

    <el-table :data="tableData" style="width: 1150px" height="400" >
        <el-table-column  prop="0" label="序号" width="80" />
        <el-table-column v-for="(prop_name,index) in this.prop_list"
                         :key="index"
                         :prop="index+1"
                         :label="prop_name"
                         width="80">
        </el-table-column>
    </el-table>
</template>

<script>
    export default {
        name: "LRU",
        data:function () {
            return{
                // 输入参数
                formData:{
                    pages:'2,3,2,1,5,2,4,5,3,2,5,2',//页面序列
                    blcoks:1,//物理块数
                    missNum:0,//缺页中断次数
                },
                // LRU算法过程记录
                tableData:[],
                // 列名表
                prop_list:[],
                // 置换列表
                ex_list:[],
            }

        },
        methods:{
            // 生成列名表（根据输入的物理块数确定列名）
            deal_prop(){
                console.log(this.formData.blcoks);
                var name="物理块";
                var prop_name="";
                for(var i=1;i<=this.formData.blcoks;i++){
                    prop_name=name+i;
                    this.prop_list.push(prop_name);
                }
                console.log("this.prop_list",this.prop_list);

            },
            // 置换链表（用于置换内存中的页面）（位于链表首端的是最近最久未使用的，新来的放在链表尾部）
            exchange_list(num){
                // 查看带调入页面是否已在内存中
                var exit_flag=0;// 标志是否在内存中
                for(var i=0;i<this.ex_list.length;i++){
                    // 如果内存中有待调入页面
                    if(num==this.ex_list[i]){
                        exit_flag=1;
                        // 将待调入页面更新到链表末尾
                        this.ex_list.splice(i,1);//删除置换链表中的待调入页面
                        this.ex_list.push(num);//将待调入页面添加在末尾
                    }
                }
                // 如果内存没有
                if(!exit_flag){
                    // 查看是否有空闲空间
                    // 如果有空闲空间
                    if(this.ex_list.length<this.formData.blcoks){//（置换链表长度如果小于物理块数，说明还有空闲空间未使用）
                        this.ex_list.push(num);//在末尾加上待调入页
                    }
                    // 如果没有空闲空间
                    else{
                        // 删除最近最久未使用的页面，并添加待调入页面在链表末尾
                        this.ex_list.splice(0,1);//删除链表首端的页
                        this.ex_list.push(num);//在末尾加上待调入页
                    }

                }
                console.log("this.ex_list",this.ex_list);

            },
            // LRU算法
            LRU(){
                // 1.初始化列名
                this.deal_prop();

                // 2.将输入的页面序列拆分成数组
                var pages = this.formData.pages.split(',');

                // 3.记录页面置换的过程
                var free_flag=this.formData.blcoks;//标志空闲物理块个数
                // 循环处理执行页面序列
                for(var i=0;i<pages.length;i++){
                    // 内存中无页面（需初始化）
                    if(i==0){
                        // 产生一次缺页中断
                        this.formData.missNum++;
                        //创建一个空白记录对象（对象成员的个数与物理块数相同）
                        var obj={};
                        obj[0]=1;//序号属性
                        for(var v=0;v<this.prop_list.length;v++){
                            obj[v+1]='--';//对象按照物理块编号
                        }
                        console.log("obj",obj);
                        // 增加一次空白记录
                        this.tableData.push(obj);
                        // 让页面序列第一个页面进入内存中
                        this.tableData[0][i+1]="页面"+pages[i];
                        // 空闲物理块-1
                        free_flag--;
                        // 置换链表更新
                        this.exchange_list(pages[i]);
                    }
                    //内存中有页面
                    else{
                        // 检查待调入页是否已在内存中
                        var exit_flag=0;//标志待调入页是否已在内存中
                        // 遍历最后一次页面置换过程的记录，查看待调入页是否已在内存中
                        for(var p=0;p<this.formData.blcoks;p++){
                            var q="页面"+pages[i];
                            if(q==this.tableData[this.tableData.length-1][p+1]){
                                exit_flag=1;
                                break;
                            }
                        }
                        // 待调入页已在物理块中
                        if(exit_flag){
                            // 增加一条记录（根据已存在的最后一条记录为模板）
                            var len=this.tableData.length;
                            var obj=JSON.parse(JSON.stringify(this.tableData[len-1]));
                            this.tableData.push(obj);
                            //修改记录的序号
                            this.tableData[len][0]=this.tableData[len][0]+1;
                            // 更新置换链表
                            this.exchange_list(pages[i]);
                        }
                        // 待调入页不在物理块中
                        else{
                            // 产生一次缺页中断
                            this.formData.missNum++;
                            // 增加一条记录（根据已存在的最后一条记录为模板）
                            var len=this.tableData.length;
                            var obj=JSON.parse(JSON.stringify(this.tableData[len-1]));
                            this.tableData.push(obj);
                            //修改序号
                            this.tableData[len][0]=this.tableData[len][0]+1;

                            // 有空闲物理块
                            if(free_flag>0){
                                // 寻找空闲的物理块
                                for(var j=0;j<this.formData.blcoks;j++){
                                    if('--'==this.tableData[len][j+1]){
                                        // 将待调入页面放入空闲物理块中
                                        this.tableData[len][j+1]="页面"+pages[i];
                                        break;
                                    }
                                    console.log("有空闲")
                                }
                                //空闲物理块-1
                                free_flag--;
                                // 更新置换链表
                                this.exchange_list(pages[i]);
                            }
                            // 无空闲物理块，寻找符合置换条件的页面
                            else{
                                // 寻找最近最久未使用的页面所在的物理块
                                for(var j=0;j<this.formData.blcoks;j++){
                                    var z="页面"+this.ex_list[0];//置换链表首端即最近最久未使用的页面
                                    console.log("z",z);
                                    if(z==this.tableData[len][j+1]){
                                        this.tableData[len][j+1]="页面"+pages[i];
                                        // 更新置换链表
                                        this.exchange_list(pages[i]);
                                        break;
                                    }
                                }
                            }

                        }
                    }
                    console.log("this.tableData",this.tableData);
                    debugger;
                }

            },

        },
    }
</script>

<style>
    .labelStyle .el-form-item__label{
        color: white;
    }
</style>
一级新生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验四-LRU算法的模拟
nanfang122的博客
05-11 2764
操作系统实验四：页式虚拟存储管理的模拟 一、实验目的： 掌握存储管理的基本原理、地址变换过程；用软件实现地址转换过程；用一种常用的页面置换算法来处理缺页中断并研究其命中率。 二、实验题目： 1、模拟请求分页存储管理的地址变换。 （1）请求分页虚拟存储器技术是把进程地址空间的全部信息存放在磁盘交换区上。当进程被选中运行时，先把进程的开始几页装入主存并启动运行。为此，在为进程建立页表时，应说明哪些页已在主存，哪些页不在主存。页表的格式如下表1所示： 表1 页表 页号 有效位 主存块号 修改位 外存地址 ︙ ︙
《操作系统》LRU和FIFO页面置换算法模拟实战
Zeeland的博客
12-04 2227
本文将介绍如何使用LRU和FIFO实现页面置换的模拟（Python实现），并使用缺页率进行算法的评价。
Vue虚拟仿真实验模板，包含图片热区、任务、设计思路、特效、上一步、下一步、初始化
刘一帆的博客
04-10 259
【代码】Vue虚拟仿真实验模板，包含图片热区、任务、设计思路、特效、上一步、下一步、初始化。
操作系统实验4 LRU算法模拟
热门推荐
一半西瓜的博客
04-28 1万+
【实验名称】LRU算法模拟 【实验目的】 1.、通过请求页式存储管理中页面置换算法模拟设计 2、了解虚拟存储技术的技术特点 3、掌握请求页式虚拟管理的页面置换算法。 【实验原理】 最近最久未使用（LRU）的页面置换算法是根据页面调入内存后的使用情况做出决策的。由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的...
算法-模拟LRU缓存机制
weixin_43391631的博客
09-11 82
已知：哈希表(unordered_map)查找get()，增，改put()为O(1)，但是无顺序，由题意看出我们需要记录进入缓存的先后。可以实现一个双向链表来完成队列的作用，最新插入的可以在队尾插入，而达到容量需要删除的则是队首的元素。最关键的是模拟双向链表如何实现，因为哈希表可以直接使用unorder_map来实现。2、定义根据节点来实现的双向链表的功能：增、删头，改，删任意点的功能。1、定义节点的类:需要定义两个指针一个指向前、一个指向后。
操作系统学习之用C语言模拟LRU算法
RongLin02的博客
06-06 3636
LRU Least Recently Used C语言
Java实现LRU算法.zip
11-13
LRU（Least Recently Used）算法是一种常见的页面替换算法，用于解决计算机内存有限而数据页数量过多的问题。...通过学习和理解LRU算法的实现，我们可以更好地理解和处理内存限制问题，提高系统的性能和效率。
LRU算法 java实现
01-15
通过以上介绍，我们可以看出LRU算法在Java中的实现主要依赖于HashMap和DoublyLinkedList这两个数据结构，它们结合在一起提供了高效且灵活的缓存管理能力。在实际应用中，LRU算法广泛应用于数据库的缓存系统、操作...
基于单链表LRU算法（java）
最新发布
05-07
基于单链表LRU算法（java）
Java实现简单LRU缓存算法
05-20
这里的LRUCache类维护了一个双向链表和一个哈希表，用于实现LRU算法。具体实现细节如下： - get方法：首先在哈希表中查找对应的键值对，如果不存在，则返回-1；如果存在，则将对应的节点从双向链表中删除，并将其...
java LRU算法介绍与用法示例
08-29
Java实现LRU算法有多种方法，下面我们将通过代码实现LRU算法。第一种方法是利用LinkHashMap，因为它本身就有一个方法就是在所设置的缓存范围内，去除掉额外的旧数据。我们可以通过重写LinkHashMap的...
实验四：LRU算法的模拟
11-28
模拟页式虚拟存储管理中硬件地址变换和缺页中断，并用LRU算法处理缺页中断
页面置换算法LRU（模拟页面管理）
11-01
页面置换算法LRU（模拟页面管理）  用高级语言编写一个页面置换算法LRU的模拟程序。  设置恰当的数据结构，有效存储数据。   动态输入存储区块数、作业调度序列。  输出分配结果、置换过程以及其它相关的信息。  界面友好，提示清晰。  容错性好。
模拟LRU算法
05-19
操作系统实验课C语言实现的实验简单的最久未使用算法
Tomasulo算法模拟器
03-14
java开发的Tomasulo算法模拟器，可以模拟六条指令并行执行，有助于理解指令级并行。
network-algorithms-simulator:用于网络问题解决算法的模拟器，例如自稳定等
06-17
网络算法模拟器 用于网络问题解决算法的模拟器，例如自稳定等。 阅读 v1.0 的评论并从下载 Mac 版。
ECE585 Tomasulo算法：C++ Tomasulo算法模拟器
qq_38334677的博客
08-14 612
Tomasulo算法的主要目标是通过动态调度和动态执行来提高指令的并行性。这种算法使用了寄存器重命名技术来消除WAR和WAW的假冒冒险，同时使用了共享的保留站来实现动态调度和动态执行。
LRU算法的实现(STL+模拟)
小谢的博客
01-16 238
题目链接:传送门 解题思路: 我们可以开两个map和一个vector进行操作，第一个vis表示元素是否在容器里面，第二个mp表示的是键值对，第三个Vector的V表示的是最近访问的内容，值得注意的是，除了vis操作，其他的操作都不会让k变为最近访问，(因为这个wa了好几次)，还有就是vis、pop、remove操作，如果不存在对应的内容，则不操作，最后注意多组输入要把这三个容器的东西清空 cod...
实验二 请求式分页存储管理算法设计与实现
qq_41162638的博客
12-04 8006
实验请求式分页存储管理算法设计与实现 1．实验内容：模拟请求页式存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断； 2．要求： ① 指令序列的设定可以执行拟定，格式如表3； ② 在完成了FIFO换页策略后，可以选做LRU的换页策略，并进行比较； ③ 作业允许的页架数m在不同情况下的缺页中断率； ④ 程序运行时显示地址转变和页面调入调出过程。 3．步骤： ① 设计页表...
lru算法java实现输出缺页率和缺页序列
06-02
好的，下面是一个简单的 Java 实现，使用 LRU（Least Recently Used）算法计算页面置换的缺页率和缺页序列： ```java import java.util.*; public class LRUPageReplacement { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print("请输入内存块数："); int numFrames = sc.nextInt(); int[] frames = new int[numFrames]; Arrays.fill(frames, -1); // 初始化为无效页 Map<Integer, Integer> pageLastUsed = new HashMap<>(); // 记录页最近使用时间 int numFaults = 0; // 缺页次数 List<Integer> pageFaults = new ArrayList<>(); // 记录缺页序列 System.out.print("请输入页面引用串（以空格分隔）："); String[] refStr = sc.next().split("\\s+"); for (String ref : refStr) { int page = Integer.parseInt(ref); boolean found = false; for (int i = 0; i < numFrames; i++) { if (frames[i] == page) { found = true; break; } } if (!found) { int leastUsedPage = -1; long minLastUsed = Long.MAX_VALUE; for (int i = 0; i < numFrames; i++) { int f = frames[i]; long lastUsed = pageLastUsed.getOrDefault(f, 0); if (lastUsed < minLastUsed) { leastUsedPage = i; minLastUsed = lastUsed; } } frames[leastUsedPage] = page; pageLastUsed.put(page, System.nanoTime()); numFaults++; pageFaults.add(page); } else { pageLastUsed.put(page, System.nanoTime()); } } double faultRate = (double) numFaults / refStr.length; System.out.printf("缺页率：%.2f%%\n", faultRate * 100); System.out.println("缺页序列：" + pageFaults); } } ``` 运行程序，输入内存块数和页面引用串，即可输出缺页率和缺页序列。例如，输入： ``` 请输入内存块数：3 请输入页面引用串（以空格分隔）：1 2 3 4 1 2 5 1 2 3 4 5 ``` 输出： ``` 缺页率：33.33% 缺页序列：[1, 2, 3, 4, 5, 1, 2, 5, 3, 4] ``` 请注意，这只是一个简单的实现，可能存在性能问题和边界情况未处理。在实际应用中，需要根据具体情况进行优化和改进。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值