缓存淘汰算法 —— LFU-Aging(Java实现)

Java实现,用HashMap保存关系{key值 : 命中次数与上次命中时间},当需要淘汰某个key值时,调用map.remove(key)。

import java.util.*;

public class LFUAgingMap<K, V> extends HashMap<K, V> {
    private static final int DEFAULT_MAX_SIZE = 3;
    private int maxSize = DEFAULT_MAX_SIZE;
    Map<K, HitRate> km = new HashMap<K, HitRate>();

    public LFUAgingMap() {
        this(DEFAULT_MAX_SIZE);
    }

    public LFUAgingMap(int maxSize) {
        super(maxSize);
        this.maxSize = maxSize;
    }

    @Override
    public V get(Object key) {
        V v = super.get(key);
        if (v != null) {
            HitRate hitRate = km.get(key);
            hitRate.hitCount += 1;
            hitRate.atime = System.nanoTime();
        }
        return v;
    }

    @Override
    public V put(K key, V value) {
        while (km.size() >= maxSize) {
            K k = getLFUAging();
  
  • 0
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我可以帮您回答这个问题。 首先,LFU缓存算法(Least Frequently Used,最少使用次数)是一种常见的缓存淘汰算法,其主要思路是淘汰缓存中使用频率最小的数据。下面是用Java实现LFU缓存算法的示例代码,固定缓存长度为10: ```java import java.util.HashMap; import java.util.Map; public class LFUCache<K, V> { private Map<K, CacheNode> cache; private int capacity; private int minFrequency; public LFUCache(int capacity) { this.capacity = capacity; cache = new HashMap<>(); } public V get(K key) { CacheNode node = cache.get(key); if (node == null) { return null; } node.frequency++; if (node.frequency > minFrequency) { minFrequency = node.frequency; } return node.value; } public void put(K key, V value) { if (capacity <= 0) { return; } CacheNode node = cache.get(key); if (node != null) { node.value = value; node.frequency++; if (node.frequency > minFrequency) { minFrequency = node.frequency; } } else { if (cache.size() >= capacity) { evict(); } node = new CacheNode(key, value); cache.put(key, node); minFrequency = 1; } } private void evict() { CacheNode minNode = null; for (CacheNode node : cache.values()) { if (minNode == null || node.frequency < minNode.frequency) { minNode = node; } } cache.remove(minNode.key); } private class CacheNode { K key; V value; int frequency = 1; CacheNode(K key, V value) { this.key = key; this.value = value; } } } ``` 这段代码中,我们使用了一个HashMap来保存缓存数据,同时还保存了每个缓存数据的访问次数(即frequency),通过比较访问次数来选择淘汰哪些数据。 接下来,我们可以编写一个简单的测试类来测试这个LFU缓存算法的效果: ```java public class LFUCacheTest { public static void main(String[] args) { LFUCache<Integer, Integer> cache = new LFUCache<>(10); for (int i = 1; i <= 20; i++) { cache.put(i, i); } System.out.println(cache.get(10)); // 10 System.out.println(cache.get(15)); // 15 System.out.println(cache.get(5)); // 5 System.out.println(cache.get(12)); // 12 System.out.println(cache.get(1)); // null System.out.println(cache.get(2)); // null } } ``` 在这个测试中,我们向缓存中添加了20个数据,然后分别访问了一些数据,最后输出了一些数据的访问结果。可以看到,我们只能缓存10个数据,当超过10个数据时,会根据访问次数淘汰一些数据。在这个测试中,我们可以看到,访问次数较少的数据(如1和2)被淘汰了,而访问次数较多的数据(如10和15)被保留下来了。 希望这个示例代码和测试能够帮助您理解LFU缓存算法实现和使用。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值