LRU算法 java实现

定义:LRU全称Least Recently Used,也就是最近最少使用的意思,是一种内存管理算法,最早应用于Linux系统。

LRU算法基于一种假设:长期不使用的数据,在未来被用到的几率也不大。因此当数据所占内存达到一个阈值是,可以选择移除掉最近最少被使用的数据来保持内存的高效使用,这是基于时间局部性原理的一个假设。LRU算法主要用于缓存算法,在节省资源的情况下提高数据访问效率。

LRU使用了哈希链表来实现。首先介绍哈希表,哈希表是由若干个key-value所组成。在逻辑上,这些key-value没有排列顺序,如下图:

在哈希链表中,key-value对在逻辑上是相互关联的,采用的双向链表的形式组织key-value对,如下图所示:

原本无序的哈希表变成在逻辑上具有前驱和后继的结构。

但是如何使用哈希链表实现LRU算法,如何将这种指向关系转化为时间上的前后呢?我们使用head和end表示链表的头和尾,在时间上先被访问的数据作为双向链表的head,后被访问的数据作为双向链表的end,当达到内存设置大小之后,新进入未被访问过的数据,则将head的节点删除,将新的数据插入end处,如果访问的数据在内存中,则将数据更新到end除,删除原始在的位置。

虽然在java中的LinkedHashMap已经对哈希链表做了很好的实现,但是还是使用HashMap来进行实现。

代码(java):

import java.util.HashMap;

/**
 * 双向链表中:head指向最久为访问的元素
 *             end指向最近未访问的元素
 */
class Node{
    Node(String key,String value){
        this.key=key;
        this.value=value;
    }
    public Node pre;
    public Node next;
    public String key;
    public String value;
}
class LRUCache {
    private Node head;
    private Node end;
    //缓存存储上限
    private int limit;

    private HashMap<String, Node> hashMap;

    public LRUCache(int limit) {
        this.limit = limit;
        hashMap = new HashMap<String, Node>();
    }

    /**
     * 删除节点
     * @param node 要删除的节点
     */
    private String removeNode(Node node) {
        if (node == end) {
            //移除尾节点
            end = end.pre;
        } else if (node == head) {
            //移除头结点
            head = head.next;
        } else {
            //移除中间节点
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
        return node.key;
    }

    /**
     * 尾部插入节点
     * @param node 要插入的节点
     * */
    private void addNode(Node node){
        if(end!=null){
            end.next=node;
            node.pre=end;
            node.next=null;
        }
        end=node;
        if(head==null){
            head=node;
        }
    }

    /*
    * 刷新被访问的节点位置
    * @param node 被访问的节点
    * */
    private void refreshNode(Node node){
        //如果访问的是尾节点,即最近未被访问的节点
        if(node==end){
            return;
        }
        //移除节点
        removeNode(node);
        //重新插入节点
        addNode((node));
    }

    public void remove(String key){
        Node node=hashMap.get(key);
        removeNode(node);
        hashMap.remove(key);
    }
    public void put(String key,String value){
        Node node=hashMap.get(key);
        if(node==null){
            //如果key不存在,插入key-value
            if(hashMap.size()>=limit){
                String oldKey=removeNode(head);
                hashMap.remove(oldKey);
            }
            node=new Node(key,value);
            addNode(node);
            hashMap.put(key,node);
        }
        else{
            //如果key存在,刷新key-value
            node.value=value;
            refreshNode(node);
        }
    }
    public String get(String key){
        Node node=hashMap.get(key);
        if(node==null){
            return null;
        }
        refreshNode(node);
        return node.value;
    }
}
class LRUMain{
    public static void main(String[] args){
        LRUCache lruCache=new LRUCache(5);
        lruCache.put("001","用户1信息");
        lruCache.put("002","用户2信息");
        lruCache.put("003","用户3信息");
        lruCache.put("004","用户4信息");
        lruCache.put("005","用户5信息");
        lruCache.get("002");
        lruCache.put("004","用户2信息更新");
        lruCache.put("006","用户6信息");
        System.out.println(lruCache.get("001"));
        System.out.println(lruCache.get("006"));
    }
}

程序运行结果:

程序结果分析:LRU容量设置为5,然后依次插入001-005的信息,lruCache.get("002")对key为002的信息进行了刷新,现在哈希链表的时间上顺序为(从左到右依次未被访问时间加长):001->003->004->005->002,再次对004信息进行更改,更改后顺序为001->003->005->002->004,插入006信息,则顺序为003->005->002->004->006,故最后访问001信息,返回null,访问006,返回用户6信息,同时最后的顺序为:003->005->002->004->006。

好的,下面是一个简单的 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] ``` 请注意,这只是一个简单的实现,可能存在性能问题和边界情况未处理。在实际应用中,需要根据具体情况进行优化和改进。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值