自定义缓存算法

已于 2022-10-02 17:17:49 修改
阅读量590 收藏
点赞数
文章标签： 缓存 算法 java
于 2022-10-01 19:17:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46159525/article/details/127135730
版权

文章目录

🍎 定义 Cache 接口

定义缓存接口的规范：

package cache;

/**
 * @author: yueLQ
 * @date: 2022-10-01 17:04
 * <p>
 * 自定义缓存接口
 */
public interface Cache {

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    public void putObj(Object key, Object val);

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    public Object getObj(Object key);

    /**
     * 移除缓存中的数据
     *
     * @return
     */
    public Object removeObj(Object key);

    /**
     * 清除缓存中的数据
     */
    public void clear();

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    public int size();
}

🍎 永久缓存 PerpetualCache

自定义永久 cache ，不定义任何缓存策略。

public class PerpetualCache implements Cache {

    /**
     * JDK 中的 hashMap 存在线程不安全的问题
     * 1. JDK7 之前可能出现死循环（环形链）
     * 2. JDK8 之后会出现值覆盖的情况
     */
    Map<Object, Object> cache = new HashMap<>();

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public void putObj(Object key, Object val) {
        cache.put(key, val);
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object getObj(Object key) {
        return cache.get(key);
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObj(Object key) {
        return cache.remove(key);
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public void clear() {
        cache.clear();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        return cache.size();
    }
}

问题：

  1. 可能出现内存溢出的情况，不可存储大量数据。
  2. 可能存在线程安全问题，不可进行多线程的数据共享。

🍎 FifoCache 缓存

基于 Fifo 算法，对象满了按照先进先出的原则移除对象，实现 cache对象。


public class FifoCache implements Cache {

    /**
     * 借助此对象进行数据的缓存
     */
    private Cache cache;

    /**
     * 借助此队列，记录 key 的顺序
     */
    private Deque<Object> keyOrders;

    /**
     * 通过此变量记录 cache 可以存储对象的个数
     */
    private int maxCap;

    /**
     * 构造器
     *
     * @param cache
     * @param maxCap
     */
    public FifoCache(Cache cache, int maxCap) {
        this.cache = cache;
        this.keyOrders = new LinkedList<>();
        this.maxCap = maxCap;
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public void putObj(Object key, Object val) {
        // 1. 记录 key 的顺序，其实存储 key 添加到队列最后位置
        keyOrders.add(key);
        // 2. 检测 cache 中存储的数据是否满了，如果满了的话则要清除
        if (keyOrders.size() > maxCap) {
            // 移除掉第一个 key
            Object eldesKey = keyOrders.removeFirst();
            cache.removeObj(eldesKey);
        }
        // 3. 放入新的对象
        cache.putObj(key, val);
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object getObj(Object key) {
        return cache.getObj(key);
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObj(Object key) {
        Object obj = cache.removeObj(key);
        keyOrders.remove(key);
        return obj;
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public void clear() {
        cache.clear();
        keyOrders.clear();
    }

    @Override
    public String toString() {
        return cache.toString();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        return cache.size();
    }

    public static void main(String[] args) {
        FifoCache cache = new FifoCache(new PerpetualCache(), 3);
        cache.putObj("A",100);
        cache.putObj("B",200);
        cache.putObj("C",300);
        cache.getObj("A");
        cache.putObj("D",400);
        cache.putObj("E",500);
        System.out.println(cache);
    }
}

🍎 LRU 算法缓存

基于 LRU 算法实现缓存，在缓存满的时候，淘汰最近最少访问的对象。
LRU算法：最近做少使用。

public class LruCache implements Cache {

    /**
     * 负责存储数据的目标 cache
     */
    private Cache cache;

    /**
     * 通过该属性记录要移除的数据对象，最近最少访问
     */
    private Object eldesKey;

    /**
     * 通过此 map 记录 key 访问顺序，次数
     */
    private LinkedHashMap<Object, Object> keyMap;

    /**
     * @param cache
     * @param cap   代表最大的容量
     */
    public LruCache(Cache cache, int cap) {
        this.cache = cache;
        this.keyMap = new LinkedHashMap<Object, Object>(cap, 0.75f, true) {
            /**
             *  该方法在执行 put 时候会执行
             *  该方法删除最旧的条目
             *  如果打算从 map 中删除最旧的条目，则 map 返回 true
             *  如果不打算从 map 中删除或者保留该条目，则返回 false
             * @param eldest
             * @return
             */
            @Override
            protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
                Boolean ifFull = size() > cap;
                if (ifFull) {
                    eldesKey = eldest.getKey();
                }
                return ifFull;
            }
        };
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public void putObj(Object key, Object val) {
        // 存储对象
        cache.putObj(key, val);
        // 记录 key 的访问顺序
        keyMap.put(key, val);
        // 移除最近最少访问的元素
        if (eldesKey != null) {
            cache.removeObj(eldesKey);
            eldesKey = null;
        }

    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object getObj(Object key) {
        // 记录 key 的访问数据，刷新使用数据
        keyMap.get(key);
        // 返回缓存数据
        return cache.getObj(key);
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObj(Object key) {
        return cache.removeObj(key);
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public void clear() {
        cache.clear();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        return cache.size();
    }

    @Override
    public String toString() {
        return cache.toString();
    }


    public static void main(String[] args) {
        Cache cache = new LruCache(new PerpetualCache(), 3);
        cache.putObj("A", 100);
        cache.putObj("B", 200);
        cache.putObj("C", 300);
        cache.getObj("A");
//        cache.getObj("C");
        cache.putObj("D", 400);
        cache.putObj("E", 500);
        System.out.println(cache);
    }
}

🍎 序列化的 cache

序列化的 cache

  1. 对象存储到 cache 之前，先进行序列化，存储到 cache 对象是一个字节的引用
  2. 反序列化
package cache;

import java.io.*;

/**
 * @author: yueLQ
 * @date: 2022-10-01 21:51
 * 
 */
public class SerializedCache implements Cache {

    private Cache cache;

    public SerializedCache(Cache cache) {
        this.cache = cache;
    }

    // 基础加强：对象序列化
    private byte[] serializa(Object val) {
        // 1. 构建对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream outputStream = null;
        bos = new ByteArrayOutputStream();
        try {
            // 装饰模式
            outputStream = new ObjectOutputStream(bos);
            // 2. 对象序列化
            outputStream.writeObject(val);
            outputStream.flush();
            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("对象序列化失败!");
        } finally {
            if (bos != null)

                try {
                    bos.close();
                    bos = null;
                } catch (Exception e) {
                }
            if (outputStream != null)

                try {
                    outputStream.close();
                    outputStream = null;
                } catch (Exception e2) {
                }
        }
    }

    private Object deserialize(byte[] array) {
        // 创建流对象
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            //1.1构建字节数组输入流，此对象可以直接读取数组中的字节信息
            bis = new ByteArrayInputStream(array);
            //1.2构建对象输入流(对象反序列化)
            ois = new ObjectInputStream(bis);
            //2.反序列化对象
            Object obj = ois.readObject();
            return obj;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //3.关闭流对象
            if (bis != null)

                try {
                    bis.close();
                    bis = null;
                } catch (Exception e) {
                }
            if (ois != null)

                try {
                    ois.close();
                    ois = null;
                } catch (Exception e2) {
                }
        }
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public void putObj(Object key, Object val) {
        // 1.将对象序列化
        byte[] array = serializa(val);
        //2.将序列化的字节存储带cache
        cache.putObj(key, array);
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object getObj(Object key) {
        // 1.基于key获取缓存中的字节数组的引用
        //2.将字节数组反序列化为对象
        return deserialize((byte[]) cache.getObj(key));
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObj(Object key) {
        return cache.removeObj(key);
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public void clear() {
        cache.clear();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        return cache.size();
    }

    public static void main(String[] args) {
        Cache cache = new SerializedCache(new PerpetualCache());
        cache.putObj("A", 200);
        cache.putObj("B", 300);
        Object v1 = cache.getObj("A");
        Object v2 = cache.getObj("A");
        System.out.println(v1 == v2);
        System.out.println(v1);
        System.out.println(v2);
    }
}

🍎 线程安全的 cache

基于 synchronized 关键字构建线程安全方法。

public class SynchronizedCache implements Cache {

    private Cache cache;

    public SynchronizedCache(Cache cache) {
        this.cache = cache;
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public synchronized void putObj(Object key, Object val) {
        cache.putObj(key,val);
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public synchronized Object getObj(Object key) {
        return cache.getObj(key);
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public synchronized Object removeObj(Object key) {
        return cache.removeObj(key);
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public synchronized void clear() {
        cache.clear();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        return 0;
    }
}

优势： 在多线程并发环境下可以保证 map 中数据的正确性。
劣势： 性能和并发都会降低。


软引用

package cache;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

/**
 * @author: yueLQ
 * @date: 2022-10-02 7:39
 * <p>
 * 软引用
 */
public class SoftCache implements Cache {

    private Cache cache;

    /**
     * 基于此对象记录被垃圾回收的对象，当软引用使用的对象被 GC 时
     * 会将被 GC 的对象软引用存储到这个队列中
     */
    private ReferenceQueue<Object> queue = new ReferenceQueue<>();

    public SoftCache(Cache cache) {
        this.cache = cache;
        this.queue = new ReferenceQueue<>();
    }

    /**
     * 软引用
     */
    class SoftEntity extends WeakReference<Object> {

        private Object key;

        /**
         * @param key
         * @param referent 被弱引用的对象，此对象 cache 的 value
         * @param queue    引用队列
         */
        public SoftEntity(Object key, Object referent, ReferenceQueue<? super Object> queue) {
            super(referent, queue);
            this.key = key;
        }


    }

    // 从队列中取出 GC 对象，然后从 cache 中移除
    private void removeGarbageObject() {
        SoftEntity soft = null;
        while ((soft = (SoftEntity) queue.poll()) != null) {
            cache.removeObj(soft.key);
        }
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public void putObj(Object key, Object val) {
        // 1. 移除队列中记录对象
        // 2. 对象进行软引用然后存储到 cache 中
        cache.putObj(key, new SoftEntity(key, val, queue));
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object getObj(Object key) {
        // 从 cache 中获取引用对象并且校验
        SoftEntity soft = (SoftEntity) cache.getObj(key);
        if (soft == null) {
            cache.removeObj(key);
        }
        // 从引用中获取引用对象
        Object target = soft.get();
        if (target == null) {
            cache.removeObj(key);
        }
        return target;
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObj(Object key) {
        // 移除垃圾对象
        removeGarbageObject();
        // 移除目标引用对象
        return cache.removeObj(key);
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public void clear() {
        removeGarbageObject();
        cache.clear();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        removeGarbageObject();
        return cache.size();
    }
}

🍎 为目标 cache 添加日志

public class LoggingCache implements Cache {

    private Cache cache;

    // 请求次数
    private int request;

    // 命中次数(表示从缓存中取到数据)
    private int hits;


    public LoggingCache(Cache cache) {
        this.cache = cache;
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @param val
     */
    @Override
    public void putObj(Object key, Object val) {
        cache.putObj(key, val);
    }

    /**
     * 获取存储的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object getObj(Object key) {
//        Auto-generated method stub
        request++;
        Object obj = cache.getObj(key);
        if (obj != null) hits++;
        return obj;
    }

    /**
     * 移除缓存中的数据
     *
     * @param key
     * @return
     */
    @Override
    public Object removeObj(Object key) {
        return cache.removeObj(key);
    }

    /**
     * 清除缓存中的数据
     */
    @Override
    public void clear() {
        cache.clear();
    }

    /**
     * 返回缓存中数据的个数
     *
     * @return
     */
    @Override
    public int size() {
        return cache.size();
    }
}

Spring Cache自定义缓存格式
无趣的码农
09-30 2233
SpringCache是一个基于注解来更新缓存的组件，对于大多数的缓存操作都适用，本质是基于AOP实现，也不用再重复千轮子，直接使用便是，并且支持SpringEL表达式，对于使用教程网上还是很多的。        很多时候为了兼容性以及方便，会把对象转换成JSON格式存入缓存（Redis）中，这就需要对Cache进行拦截，在加入缓存及获取缓存时做一个JSON格式转换。        通过@En
Spirng Cache(第二篇)自定义配置
孙平平的博客
12-09 3420
Spirng Cache(第二篇)自定义配置 从3.1版开始，Spring Framework提供了对现有Spring应用程序透明地添加缓存的支持。与事务 支持类似，缓存抽象允许一致地使用各种缓存解决方案，而对代码的影响最小。 从Spring 4.1开始，通过JSR-107注释和更多自定义选项的支持，缓存抽象得到了显着改进。 这篇介绍下如果根据Spring 缓存注解实现我们的自定义配置 文章目录S...
spring自定义cache
要么牛逼，要么牛逼
10-21 853
下面是一个较为详细的spring缓存的介绍 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/   Cacheable注解，是spring支持的一个注解，用法就不多说了，但是发现了一个奇怪的用法，Cacheable的value属性官方定义为缓存的名字，但是在这里却被当成了缓存的失效时长。 /**...
【缓存】自定义CacheManager
...
06-27 1045
原理： 1、CacheManager（缓存管理器）创建Cache（缓存组件），缓存组件来实际的给缓存中存储数据。 2、引入redis的starter，容器中保存的是RedisCacheManager。 3、RedisCacheManager帮我们创建RedisCache。RedisCache通过操作Redis来缓存数据。 4、当k-v都是Object的时候，默认使用序列化保存数据，我们可以使用json格式序列化和反序列化缓存的键-值。 示例： 在【缓存】整合Redis的基础上进行修改： MyRedisCon
【spring】自定义二级Cache
morris
04-28 921
Spring Cache是Spring-context包中提供的基于注解方式使用的缓存组件，定义了一些标准接口，通过实现这些接口，就可以通过在方法上增加注解来实现缓存。这样就能够避免缓存代码与业务处理耦合在一起的问题。 Spring Cache核心的接口就两个：Cache和CacheManager。 Cache接口：该接口定义提供缓存的具体操作，比如缓存的放入、读取、清理： CacheManager接口：主要提供Cache实现bean的创建，每个应用里可以通过cacheName来对Cache进行隔离，每个
Mybatis缓存 自定义缓存
just_learing的博客
04-03 993
Mybatis缓存 自定义缓存
Android 中okhttp自定义Interceptor（缓存拦截器）
08-31
当缓存大小超过这个限制时，OkHttp会自动使用LRU算法删除旧的缓存条目。 总结来说，通过自定义Interceptor，我们能够在Android应用中实现对OkHttp的精细控制，特别是对于缓存策略的定制。这样，即使服务器没有提供...
自定义缓存类
07-02
本主题将深入探讨如何在C#环境下为Windows Forms和Web应用程序自定义缓存类。 自定义缓存类的设计通常基于需求，如缓存策略、数据过期机制、内存管理等。在C#中，我们可以利用.NET框架提供的System.Web.Caching....
Java 实现自定义缓存系统（支持过期时间和最大容量）
最新发布
安
01-13 390
这个自定义缓存系统不仅支持基本的缓存存取操作，还包括了过期时间和 LRU 清理策略的实现。通过使用锁和定时任务，确保了线程安全和缓存数据的定期清理，非常适合高并发环境中的数据缓存需求。
C#开发中自定义缓存类的应用与实现
自定义缓存类是开发过程中常用于优化应用程序性能的一种技术。它能够在应用程序运行时暂存数据，减少数据库或网络请求次数，从而加快数据访问速度和提升用户体验。自定义缓存类适用于多种开发场景，包括但不限于C# ...
SpringCache与redis集成，优雅的缓存解决方案
十指波课堂的博客
12-11 268
缓存可以说是加速服务响应速度的一种非常有效并且简单的方式。在缓存领域，有很多知名的框架，如EhCache 、Guava、HazelCast等。Redis作为key-value型数据库，由于他的这一特性，Redis也成为一种流行的数据缓存工具。在传统方式下对于缓存的处理代码是非常臃肿的。例如：我们要把一个查询函数加入缓存功能，大致需要三步。在函数执行前，我们需要先检查缓存中是否存在数据，如果存在则返...
Spring-Boot-内存缓存Caffiene自定义CacheManager
Java程序员的知识博客
02-17 2801
上一篇介绍了Caffiene整合Spring的缓存注解@Cacheable，在这篇示例中，所有的缓存公用，但是实际的场景中，我们可能会更希望针对不同的场景，配置不同的缓存（比如我的关键数据，虽然访问频率可能没那么高，但是每次实际读取的成本很高，又不怎么变动，我希望可以更长久的缓存；不希望这些数据因为缓存的淘汰策略被其他的热点数据给淘汰掉），那么可以怎么处理呢？接下来我们来看一下两种不同的方式，来实现上面的诉求。
缓存类实现Cache接口
van334的博客
07-20 644
package com.oracle.ssm.shop.cache; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cache.Cache; import org.springframework.cache.support.SimpleValueWrapper; import org.springframework.dao.DataAccessException; imp.
Redis分布式缓存的实现
qq_41936090的博客
01-20 2724
Redis分布式缓存的实现 什么是缓存： 定义：就是计算机内存中一段数据 内存中数据特点： 读写快 断电立即丢失 缓存解决了什么问题？ 提高了网站吞吐量提高网站运行效率 核心解决问题：缓存的存在是用来减轻数据库访问压力 既然缓存能提高效率，那项目中所有数据加入缓存，岂不是更好？ 注意：使用缓存时一定是数据库中数据极少发生修改，更多用于查询这种情况 本地缓存和分布式缓存区别？ 本地缓存：存在应用服务器内存中数据称之为本地缓存（local cache） 分布式缓存：存储在当前应用服务
带你彻底搞懂MyBatis的底层实现之缓存模块(Cache)-吊打面试官必备技能
2301_76238237的博客
04-07 974
本文从基础到高级再到实战，由浅入深，把MySQL讲的清清楚楚，明明白白，这应该是我目前为止看到过最好的有关MySQL的学习笔记了，我相信如果你把这份笔记认真看完后，无论是工作中碰到的问题还是被面试官问到的问题都能迎刃而解！MySQL50道高频面试题整理：《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！[外链图片转存中…(img-dpwR7lm3-1712433293092)][外链图片转存中…(img-JcutYsbO-1712433293092)]
将ReadWriteLock应用到缓存设计中
刘飞
12-14 124
基础类： [code="java"]package org.zzuli.xmsb.util.cache; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.Reentra...
Mybatis缓存（二）-Cache的各个实现类的分析
daliucheng的博客
09-13 380
继上一篇之后，继续介绍了Cache的各个实现类，和对Cache的思考。从源码角度来分析Mybatis缓存的具体实现。快来看看吧
Spring Cache集成redis
zhuasheng
06-20 7475
Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式
java 缓存事务_手写mybatis框架-增加缓存&事务功能
weixin_39672443的博客
02-27 200
增加代码详解缓存 com.simple.ibatis.cache缓存接口-CachepublicinterfaceCache{/**放入缓存*/voidputCache(Stringkey,Objectval);/**获取缓存*/ObjectgetCache(Stringkey);/**清空缓存*/voidcleanCache();/**获取缓存健数量*/intgetSize(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

光头小小强007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值