基于ConcurrentHashMap实现一个自定义的缓存工具

已于 2023-02-25 01:38:18 修改
阅读量811 收藏 9
点赞数 1
分类专栏： Java工具 java算法 文章标签： 缓存 java jvm
于 2023-02-25 00:22:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42304484/article/details/129210511
版权

本博客主要内容为基于ConcurrentHashMap实现一个自定义的缓存工具类。

该缓存工具具有以下功能：
  1. 支持初始化容量控制
  2. 支持泛型
  3. 支持插入具有过期时间的key
  4. 支持过期key惰性删除
  5. 支持冷数据淘汰功能

工具类代码如下：

1、缓存工具接口

package com.syx.cache;

import java.util.concurrent.TimeUnit;

/**
 * @Author whh
 * @Date: 2023/02/24/ 18:52
 * @description
 */
public interface Cache<K, V> {


    /**
     * 缓存中添加元素 可设置key的过期时间
     * @param key
     * @param val
     * @param timeout
     * @param timeUnit
     */
    void put(K key, V val, long timeout, TimeUnit timeUnit);


    /**
     *缓存中添加元素
     * @param key
     * @param val
     */
    void put(K key, V val);

    /**
     *清空缓存
     */
    void clear();

    /**
     *检查 key是否过期 不存在或过期 返回true 否则返回false
     * 如果该key过期同时删除key
     * @param key
     * @return
     */
    boolean expire(K key);

    /**
     *检查 key在指定的时间偏移量内是否过期 不存在或过期 返回true 否则返回false
     * @param key
     * @param time
     * @param timeUnit
     * @return
     */
    boolean expireAt(K key, long time, TimeUnit timeUnit);

    /**
     *获取缓存中的值
     * @param key
     * @return
     */
    V get(K key);

    /**
     *缓存中的数据量
     * @return
     */
    int size();
}

2、接口实现工具类

package com.syx.cache;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

/**
 * @Author whh
 * @Date: 2023/02/24/ 18:51
 * @description
 */
public class CacheUtil<K, V> implements Cache<K, V> {

    //默认缓存容量
    private static final int DEFAULT_CAPACITY = 50000;

    //设定的缓存容量
    private int capacity;

    //发布缓存工具的实例
    private static CacheUtil INSTANCE;
    //锁对象
    private final Object lock = new Object();

    //具体的缓存容器的具体实现
    private ConcurrentHashMap<K, Value<K, V>> cache;

    //使用私有构造函数避免用户创建实例
    private CacheUtil(int capacity) {
        if (capacity == 0) {
            this.capacity = DEFAULT_CAPACITY;
        }
        this.capacity = capacity;
        this.cache = new ConcurrentHashMap<>(this.capacity);
    }


    /**
     * 缓存中添加元素 可设置key的过期时间
     *
     * @param key
     * @param val
     * @param timeout  key的过期时间
     * @param timeUnit 时间单位
     */
    @Override
    public void put(K key, V val, long timeout, TimeUnit timeUnit) {
        //淘汰元素
        eliminate();
        Value<K, V> value = new Value<>(key, val, timeout, timeUnit);
        cache.put(key, value);

    }


    /**
     * 缓存中添加元素
     *
     * @param key
     * @param val
     */
    @Override
    public void put(K key, V val) {
        //淘汰元素
        eliminate();
        Value<K, V> value = new Value<>(key, val, 0, null);
        cache.put(key, value);
    }

    /**
     * 清空缓存
     */
    @Override
    public void clear() {
        cache.clear();
    }

    /**
     * 检查 key是否过期 不存在或过期 返回true 否则返回false
     * 如果该key过期同时删除key
     *
     * @param key
     * @return
     */
    @Override
    public boolean expire(K key) {
        Value<K, V> value = cache.get(key);
        if (value == null || value.timeout == 0) {
            return false;
        }
        boolean expire = (System.currentTimeMillis() - value.timestamp) > TimeUnit.MILLISECONDS.convert(value.timeout, value.unit);
        if (expire) {
            cache.remove(key, value);
        }
        return expire;
    }


    /**
     * 检查 key在指定的时间偏移量内是否过期 不存在或过期 返回true 否则返回false
     *
     * @param key
     * @param timeOffset
     * @param timeUnit
     * @return
     */
    @Override
    public boolean expireAt(K key, long timeOffset, TimeUnit timeUnit) {
        Value<K, V> value = cache.get(key);
        if (value == null || value.timeout == 0) {
            return false;
        }
        return TimeUnit.MILLISECONDS.convert(timeOffset, timeUnit) > TimeUnit.MILLISECONDS.convert(value.timeout, value.unit);
    }


    /**
     * 获取缓存中的值
     *
     * @param key
     * @return
     */
    @Override
    public V get(K key) {
        if (expire(key)) {
            return null;
        }
        Value<K, V> val = cache.get(key);
        if (val == null) return null;
        val.count.incrementAndGet();
        return val.val;
    }


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


    /**
     * 淘汰策略
     * 1、如果初始的容量小于100
     */
    private void eliminate() {
        if (cache.size() >= capacity) {//如果当前容器中的数据量超过了规定的容量则进行数据淘汰

            synchronized (lock) {

                Collection<Value<K, V>> values = cache.values();
                long expire = values.stream().filter(Value::expire).count();

                if ((expire > capacity / 2)) {//如果容器中的过期数据占比超过1/2则创建新容器并复制数据
                    cache = new ConcurrentHashMap<>(capacity);
                    values.stream().filter(e -> !e.expire()).forEach(data -> {
                        //数据复制
                        cache.put(data.key, data);
                    });
                } else {//否则创建新的容器将原容器中未过期的数据按照访问量降序排列  取列表前1/5的数据并复制到新的容器
                    cache = new ConcurrentHashMap<>(capacity);

                    cache.values().stream()
                            .filter(e -> !e.expire())
                            .sorted((o1, o2) -> o2.count.get() - o1.count.get())
                            .limit(size() / 5).forEach(data -> {
                        //数据复制
                        cache.put(data.key, data);

                    });

                }

            }

        }
    }


    /**
     * top count
     * 查询容器中访问前top的数据 格式为 {key,count}
     *
     * @param top
     * @return
     */
    public List<Map<K, Integer>> top(int top) {
        if (top > 100) throw new IllegalArgumentException("top must no more than 100");
        return cache.values().stream().sorted((o1, o2) -> o2.count.get() - o1.count.get()).limit(top).map(e -> {
            HashMap<K, Integer> map = new HashMap<>();
            map.put(e.key, e.count.get());
            return map;
        }).collect(Collectors.toList());
    }

    public int getCapacity() {
        return capacity;
    }

    public static CacheUtil getINSTANCE(int capacity) {
        if (INSTANCE == null) {
            synchronized (CacheUtil.class) {
                if (INSTANCE == null) {
                    INSTANCE = new CacheUtil(capacity);
                }
            }
        }
        return INSTANCE;
    }

    /**
     * 缓存容器中真正存储的 value数据
     *
     * @param <K>
     * @param <V>
     */
    private static class Value<K, V> {
        private K key;//用户传入缓存的key
        private V val; //用户缓存传入缓存的value
        private long timestamp;//时间戳
        private long timeout;//key的过期时间
        private TimeUnit unit;//时间单位
        private AtomicInteger count;//保存该条数据的访问量

        public Value(K key, V val, long timeout, TimeUnit unit) {
            this.key = key;
            this.val = val;
            this.timestamp = System.currentTimeMillis();
            this.timeout = timeout;
            this.unit = unit;
            this.count = new AtomicInteger();
        }

        /**
         * 是否过期
         *
         * @return
         */
        public boolean expire() {
            return (System.currentTimeMillis() - timestamp) > TimeUnit.MILLISECONDS.convert(timeout, unit);
        }

        public K getKey() {
            return key;
        }

        public V getVal() {
            return val;
        }

        public long getTimestamp() {
            return timestamp;
        }

        public long getTimeout() {
            return timeout;
        }

        public TimeUnit getUnit() {
            return unit;
        }

        public AtomicInteger getCount() {
            return count;
        }

        @Override
        public String toString() {
            return "Value{" +
                    "key=" + key +
                    ", val=" + val +
                    ", timestamp=" + timestamp +
                    ", timeout=" + timeout +
                    ", unit=" + unit +
                    ", count=" + count +
                    '}';
        }
    }
}

3、测试

import com.syx.cache.CacheUtil;

import java.util.concurrent.TimeUnit;

/**
 * @Author whh
 * @Date: 2023/02/24/ 19:36
 * @description
 */
public class CacheTest {
    public static void main(String[] args) throws InterruptedException {
        fn1();

    }


    public static void fn1() throws InterruptedException {
        CacheUtil<String,String> cache = CacheUtil.getINSTANCE(10);


        cache.put("key","whh",10,TimeUnit.MILLISECONDS);


        cache.put("ls","ls");
        cache.put("wz","wz");

        cache.put("ww","ww");
        System.out.println(cache.expire("key"));

        Thread.sleep(12);

        System.out.println(cache.expire("key"));

        System.out.println(cache.size());

        cache.get("wz");

        cache.get("wz");
        cache.get("ls");

        System.out.println(cache.top(10));

    }
}

4、测试结果

在这里插入图片描述

目前该工具还需进一步压测，以测试其性能，如有问题请大家指正。

限流（服务降级）：基于自定义注解+切面的方式实现接口调用频率限制
专注于计算机研发知识和资讯分享
06-07 259
背景：提供接口给下游（外部厂商）的接口，通过控制IP地址来限制接口的调用频率，可以有效保护系统的稳定性和安全性。限制接口调用频率实现方案： 2.1 检查IP是否超过频率限制 (无法灵活控制限制时间范围) 共用一个RateLimiter,无法灵活控制限制时间范围。使用CacheBuilder来构建LoadingCache实例，可以链式调用多个方法来配置缓存的行为。其中CacheLoader可以理解为一个固定的加载器，在创建LoadingCache时指定，然后简单地重写V load(K key) throws
缓存类型及实现方式
weixin_56005963的博客
08-04 465
数据交换的缓冲区（Cache），程序访问频繁数据会从内存复制到缓存，供程序读取，由于缓存的访问速度高于内存，从而提升程序读写数据速度。
基于ConcurrentHashMap实现带时限的缓存
留下的兵
10-18 3958
利用缓存，减少服务器与数据库之间的频繁交互，从而提高效率。
用ConcurrentHashMap作缓存
11-28 1862
// 用map实现一个简单的缓存功能 public class MapCacheDemo { // 我使用了 ConcurrentHashMap，线程安全的要求。 //我使用SoftReference 作为映射值，因为软引用可以保证在抛出OutOfMemory之前，如果缺少内存，将删除引用的对象。 //在构造函数中，我创建了一个守护程序线程，每5秒扫描一次并清理过期的对象。 private static final int CLEAN_UP_PERIOD_IN_SE.
缓存之美：从根上理解 ConcurrentHashMap
最新发布
Andrew_Chenwq的博客
02-19 1252
本文将详细介绍构造方法、添加值方法和扩容操作等源码实现。是线程安全的哈希表，此哈希表的设计主要目的是在最小化更新操作对哈希表的占用，以保持并发可读性，次要目的是保持空间消耗与HashMap相同或更好，并支持利用多线程在空表上高效地插入初始值。在 Java 8 及之后的版本，使用关键字、合适的和volatile。
使用concurrentHashMap实现缓存
weixin_44857939的博客
04-19 1960
2、使用@PostConstruct注解init函数，在生成bean的时候会调用init函数。init函数进行concurrenthashMap的初始化，分配初始空间大小。并且开启线程每隔一段时间处理清空缓存，flushAlll。3、如果一个key需要存多条消息，并发很高，可以考虑分桶，使用多个concurrentHashMap，根据key来决定放到那个Map保存，Map里面使用另外的key进行散列。4、add向缓存添加元素，map元素个数大于阈值，则进行缓存处理清理。
使用ConcurrentHashMap实现数据缓存
Shhshdhhd的博客
06-02 1720
实现逻辑: 使用ConcurrentHashMap存储缓存数据,再定义一个生效时间及获取单个缓存时间的对应标识符,废话不多说直接上代码. package com.ane56.route.opt.stock.utils; import java.util.concurrent.ConcurrentHashMap; /** * @program: route-forecast * @description: map预缓存 * @author: rzx * @create: 2021-06-01 15
ConcurrentHashMap实现本地缓存
m0_47703468的博客
11-10 816
【代码】ConcurrentHashMap实现本地缓存。
基于Java的源码-Java缓存工具 SimpleCache.zip
07-16
总结来说，SimpleCache是一个强大且灵活的Java缓存工具，它的设计理念在于提供简单易用的API，同时支持多种缓存策略和自定义序列化，确保在多线程环境下运行稳定。通过理解并掌握SimpleCache的源码，开发者不仅能...
从零开始：Guava Hashing自定义缓存系统全攻略
Guava Hashing是Google开发的一个Java库，它提供了强大的数据处理能力，特别在哈希计算和缓存机制方面。它不仅可以简化数据结构的使用，还能够优化数据处理效率。 ## 1.2 缓存的基本概念 缓存是一种存储临时数据的...
从自定义一个作用域开始来了解SpringBean的作用域
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
05-01 1161
Spring6提供了多种Bean作用域。本文从作用域demo、自定义设计作用域到作用域Spring实现来全方位了解作用域。以及说明了单例bean里面注入了原型bean这种bug级操作怎么解决。
使用 ConcurrentHashMap 实现一个本地缓存服务，系统快多了！
weixin_44421461的博客
06-07 1484
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析...
使用ConcurrentHashMap实现缓存
一个真实、有温度的无名小卒
08-29 1万+
说实话在各种第三方工具和缓存机制的成熟方案太多了，使用Java原生的ConcurrentHashMap意义实在不大，但是有时候自己想偷懒就用个简单的缓存ConcurrentHashMap还是能用的上的，首先我们要了解ConcurrentHashMap是什么？ ConcurrentHashMap的简要总结： 1、public V get(Object key)不涉及到锁，也就是说获得对象时没有使...
ConcurrentHashMap实现缓存功能
sunsiny
10-16 556
ConcurrentHashMap
用ConcurrentHashMap 实现JVM缓存
t_liuyong的专栏
03-25 855
为什么用缓存 提升应用程序性能 降低数据库成本 减少后端负载 可预测的性能 消除数据库热点 提高读取吞吐量（IOPS） 读多写少用缓存 常用的分布式缓存有Redis、Memcached等。 但是在单机的情况下，咱们完全可以使用内部缓存达到更好的效果。当需要扩展为分布式集群环境时，更改实现类就可以了。 JSR107规范 http://jcp.org/en/jsr/detail?id=107 ...
一步步，利用ConcurrentHashMap实现缓存工具类
热门推荐
hu10131013的博客
07-10 13万+
很多时候都需要使用到缓存工具-(不过目前有很多专业的缓存工具，写这个东西仅仅是为了梳理缓存的逻辑) 首先定义一个存储工具使用的ConcurrentHashMap(支持并发) private volatile Map<String, CacheObject> data = new ConcurrentHashMap<>(16); 缓存应该具备到期自动删除的功能，所以需要对要存储的对象进行包装 @Data class CacheObject { ...
ConcurrentHashMap实现缓存池
小鹏子的博客
04-10 3145
Map实现缓存池介绍 缓存池是基于map实现的一种本机缓存的解决方案，优点就是不会重复创建对象（复用性），避免浪费资源和Gc回收造成的开销和查询Map复用对象比较快，缺点也显而易见因为他是通过Map来存储该复用对象，所以受限于map的值不易被Gc回收，一直保存到内存中，如果使用map来存储大量复用的数据，一直不能清除的话会导致内存泄漏。 -ps 使用基于Map缓存池要考虑业务场景，如果是复用对象是有边界则可以使用（如：文件存储对象，消息队列名等），如果是无边界的不推荐使用（如：用户对象，商品对象等）
ConcurrentHashMap实现本地缓存工具类
weixin_55988155的博客
07-27 483
自用
使用ConcurrentHashMap实现高效缓存框架
田维常
05-04 1606
点击箭头处“蓝色字”，关注我们哦！！在项目中我们有的时候需要使用某种形式的缓存，使用缓存能够重用之前的计算结果，降低系统延迟，提高吞吐量，但是其却会消耗更多的内存...
SimpleCache.zip - Java缓存工具开发源码下载
SimpleCache作为一个基础缓存工具，可能不会提供复杂的同步机制，因此开发者需要在应用中合理地处理缓存数据的一致性和更新问题。 **总结** SimpleCache是一个实用的Java缓存工具，它以其简洁的API、开源特性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值