精华内容
下载资源
问答
  • JAVA 实现本地缓存

    2021-02-26 15:09:41
    JAVA 实现本地缓存(可直接复用) 本来想上传上去给大家要用积分下载的,后来想想算了,给大家直接免费用吧 网上的闲杂的代码太多,所以集成了一下,这个本人已经测试过,完成可以用,一共是两个类,一个是Local...

    JAVA 实现本地缓存(可直接复用)

    本来想上传上去给大家要用积分下载的,后来想想算了,给大家直接免费用吧

    网上的闲杂的代码太多,所以集成了一下,这个本人已经测试过,完成可以用,一共是两个类,一个是LocalCache,另外一个是CacheEntity

    LocalCache 类(主类) ,实现本地缓存的主体

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.*;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @ClassName LocalCache
     * @Description
     * @Author 
     * @Date 
     * @Version 1.0
     */
    
    public class LocalCache {
    
        private static final Logger log = LoggerFactory.getLogger(LocalCache.class);
    
        /**
         * 默认的缓存容量
         */
        private static final int DEFAULT_CAPACITY = 512;
        /**
         * 最大容量
         */
        private static final int MAX_CAPACITY = 100000;
        /**
         * 刷新缓存的频率
         */
        private static final int MONITOR_DURATION = 2;
    
        // 启动监控线程  
        static {
            new Thread(new TimeoutTimerThread()).start();
        }
    
        // 内部类方式实现单例
        private static class LocalCacheInstance{
            private static final LocalCache INSTANCE=new LocalCache();
    
        }
        public static LocalCache getInstance() {
            return LocalCacheInstance.INSTANCE;
        }
    
        private LocalCache() {
        }
    
        /**
         * 使用默认容量创建一个Map
         */
        private static Map<String, CacheEntity> cache = new ConcurrentHashMap<>(DEFAULT_CAPACITY);
    
        /**
         * 将key-value 保存到本地缓存并制定该缓存的过期时间
         *
         * @param key
         * @param value
         * @param expireTime 过期时间
         * @return
         */
        public <T> boolean putValue(String key, T value, int expireTime) {
            return putCloneValue(key, value, expireTime);
        }
    
        /**
         * 将值通过序列化clone 处理后保存到缓存中,可以解决值引用的问题
         *
         * @param key
         * @param value
         * @param expireTime
         * @return
         */
        private <T> boolean putCloneValue(String key, T value, int expireTime) {
            try {
                if (cache.size() >= MAX_CAPACITY) {
                    return false;
                }
                // 序列化赋值 license缓存是直接加入object所以序列化克隆不需要
                CacheEntity entityClone = new CacheEntity(value, System.nanoTime(), expireTime);
                cache.put(key, entityClone);
                return true;
            } catch (Exception e) {
                log.error("添加缓存失败:{}", e.getMessage());
            }
            return false;
        }
    
        /**
         * 序列化 克隆处理
         *
         * @param object
         * @return
         */
        private <E extends Serializable> E clone(E object) {
            E cloneObject = null;
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(object);
                oos.close();
                ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bais);
                cloneObject = (E) ois.readObject();
                ois.close();
            } catch (Exception e) {
                log.error("缓存序列化失败:{}", e.getMessage());
            }
            return cloneObject;
        }
    
        /**
         * 从本地缓存中获取key对应的值,如果该值不存则则返回null
         *
         * @param key
         * @return
         */
        public Object getValue(String key) {
            //加入为空判断,若不加则报错
            if (cache.get(key) == null){
                return null;
            }
            return cache.get(key).getValue();
        }
    
        /**
         * 清空所有
         */
        public void clear() {
            cache.clear();
        }
    
        /**
         * 过期处理线程
         */
        static class TimeoutTimerThread implements Runnable {
            @Override
            public void run() {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(MONITOR_DURATION);
                        checkTime();
                    } catch (Exception e) {
                        log.error("过期缓存清理失败:{}", e.getMessage());
                    }
                }
            }
    
            /**
             * 过期缓存的具体处理方法
             *
             * @throws Exception
             */
            private void checkTime() throws Exception {
                // 开始处理过期
                for (String key : cache.keySet()) {
                    CacheEntity tce = cache.get(key);
                    long timoutTime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - tce.getGmtModify());
                    // 过期时间 : timoutTime
                    if (tce.getExpire() > timoutTime) {
                        continue;
                    }
                    log.info(" 清除过期缓存 : " + key);
                    //清除过期缓存和删除对应的缓存队列
                    cache.remove(key);
                }
            }
        }
    }

    ---------------------------------------------------------------------------------------------------------------------------------------- 

    CacheEntity类

    import lombok.Data;
    
    import java.io.Serializable;
    
    @Data
    public class CacheEntity implements Serializable {
    
        private static final long serialVersionUID = 2594373766348228819L;
    
        /**
         * 值
         */
        private Object value;
    
        /**
         * 保存的时间戳
         */
        private long gmtModify;
    
        /**
         * 过期时间
         */
        private int expire;
    
        public CacheEntity(Object value, long gmtModify, int expire) {
            super();
            this.value = value;
            this.gmtModify = gmtModify;
            this.expire = expire;
        }
    
    }

    @Data 是lombok的注解,大家可以直接用get,set解决,这我就懒得写

    下面写几个示例

    LocalCache localCache = LocalCache.getInstance();  //初始化本地缓存
    
    LicenseVO license = (LicenseVO)localCache.getValue(CacheKey.LICENSE); //根据本地缓存自定义的名称获取
    
    localCache.putValue(CacheKey.LICENSE,license,0); //永不过期,放入缓存的参数

    基本这几个方法,大部分的业务代码都能搞了。就这,谢谢大家。

     

     

    展开全文
  • Java实现本地缓存

    2019-12-26 09:31:02
    java实现本地缓存 缓存 缓存,将程序或系统中重复用到的数据缓存在内存中,加快访问速度,减少系统开销,提高系统效率的方案。 数据存储方式主要分2种: 文件 数据保存在文件中,做持久化。 内存 数据保存在内存中...

    java实现本地缓存

    缓存

    缓存,将程序或系统中重复用到的数据缓存在内存中,加快访问速度,减少系统开销,提高系统效率的方案。

    数据存储方式主要分2种:

    1. 文件 数据保存在文件中,做持久化。
    2. 内存 数据保存在内存中,也就是创建一个静态内存区域,本文中数据保存在静态区域,使用MAP保存key\value数据。

    开源缓存框架

    • Redis
      Redis是基于内存、可持久化的日志型、Key-Value数据库高性能存储系统,并提供多种语言的API.
    • memcached
      是一个自由开源的,高性能,分布式内存对象缓存系统。基于内存的key-value存储,用来存储小块的任意数据(字符串、对象)。

    解决场景

    目前在开发的项目中,不希望引入太多外部服务,引入分布式缓存框架例如Redis,还需要部署与维护,这会大大增加对项目的维护成本。

    Java实现本地缓存框架逻辑

    框架基本定义

    • 数据存储格式 key-value,仅针对字符串缓存。
    • 数据有效性,增加超时时间失效逻辑
    • 失效策略:定期删除与懒惰淘汰并行

    定期删除策略

    定期删除策略是每隔一段时间检测已过期的缓存,并且降之删除。这个策略的优点是能够确保过期的缓存都会被删除。同时也存在着缺点,过期的缓存不一定能够及时的被删除,这跟我们设置的定时频率有关系,另一个缺点是如果缓存数据较多时,每次检测也会给 cup 带来不小的压力。

    懒惰淘汰策略

    懒惰淘汰策略是在使用缓存时,先判断缓存是否过期,如果过期将它删除,并且返回空。这个策略的优点是只有在查找的时候,才判断是否过期,对 CUP 影响较小。同时这种策略有致命的缺点,当存入了大量的缓存,这些缓存都没有被使用并且已过期,都将成为无效缓存,这些无效的缓存将占用你大量的内存空间,最后导致服务器内存溢出。
    我们简单的了解了一下 Redis 的两种过期缓存处理策略,每种策略都存在自己的优缺点。所以我们在使用过程中,可以将两种策略组合起来,结合效果还是非常理想的。

    逻辑顺序

    1. 定义缓存map, 定义定时移除时效数据的任务,在static代码块中初始化。
    2. 定义缓存对象,包含值和过期时间。
    3. 定义定时移除时效数据的异步任务。
    4. 实现俩种时效策略移除数据的逻辑 remove + removeAll.
    5. 实现put与get方法。

    框架中用到的定时任务模块

    private final static ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    executor.scheduleAtFixedRate(new Task(), INITIAL_DELAY_TIME, PERIOD_TIME, TimeUnit.SECONDS);

    初始化线程池,启动定时执行任务scheduleAtFixedRate

    1. new Task() 定时任务执行的具体业务逻辑
    2. INITIAL_DELAY_TIME 启动后延迟时间执行(秒)
    3. PERIOD_TIME 每次执行间隔(秒)

    执行结果

    定时任务策略:延迟5秒执行,每隔5秒执行一次 (实际失效策略时间可以放长一点)

    首先添加缓存数据

    LocalCache.put("a", "10a", 7);
    LocalCache.put("b", "10b", 12);
    LocalCache.put("c", "10c", 30);
    2019-12-25 21:00:19,914 [http-nio-9060-exec-1] INFO LocalCache 62 - 添加缓存,key=a, value=10a, expire=7秒
    2019-12-25 21:00:19,915 [http-nio-9060-exec-1] INFO LocalCache 62 - 添加缓存,key=b, value=10b, expire=12秒
    2019-12-25 21:00:19,915 [http-nio-9060-exec-1] INFO LocalCache 62 - 添加缓存,key=c, value=10c, expire=30秒
    

    定时任务执行第二次 10s后,移除缓存数据a

    2019-12-25 21:00:24,919 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={a=LocalCache.Cache(value=10a, expire=1577278826915), b=LocalCache.Cache(value=10b, expire=1577278831915), c=LocalCache.Cache(value=10c, expire=1577278849915)}
    2019-12-25 21:00:29,918 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={a=LocalCache.Cache(value=10a, expire=1577278826915), b=LocalCache.Cache(value=10b, expire=1577278831915), c=LocalCache.Cache(value=10c, expire=1577278849915)}
    2019-12-25 21:00:29,919 [pool-3-thread-1] INFO LocalCache 94 - 定期删除策略: 移除超时失效数据, key=a, value=10a, time=1577278826915
    

    定时任务执行第三次 15s后,移除缓存数据b

    2019-12-25 21:00:34,918 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={b=LocalCache.Cache(value=10b, expire=1577278831915), c=LocalCache.Cache(value=10c, expire=1577278849915)}
    2019-12-25 21:00:34,919 [pool-3-thread-1] INFO LocalCache 94 - 定期删除策略: 移除超时失效数据, key=b, value=10b, time=1577278831915
    

    定时任务执行第六次 30s后,移除缓存数据c

    2019-12-25 21:00:39,918 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={c=LocalCache.Cache(value=10c, expire=1577278849915)}
    2019-12-25 21:00:44,919 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={c=LocalCache.Cache(value=10c, expire=1577278849915)}
    2019-12-25 21:00:49,918 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={c=LocalCache.Cache(value=10c, expire=1577278849915)}
    2019-12-25 21:00:49,919 [pool-3-thread-1] INFO LocalCache 94 - 定期删除策略: 移除超时失效数据, key=c, value=10c, time=1577278849915
    2019-12-25 21:00:54,918 [pool-3-thread-1] INFO LocalCache 89 - 定期删除策略: 开始执行, store={}
    

    在这里插入图片描述

    源码

    package com.core.mall.config.cache;
    
    import lombok.Data;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.concurrent.*;
    
    /**
     * 本地缓存服务
     * key = 字符串 | value = 字符串 | expire = 秒(有效时间)
     *
     * put 添加缓存
     * get 读取缓存值
     *
     * 失效策略:
     *  1. 定期删除策略:启动1个线程,每2分钟扫描一次,超时数据移除
     *  2. 懒惰淘汰策略:每次访问时校验有效性,如果失效移除
     */
    public class LocalCache {
        private final static Logger logger = LoggerFactory.getLogger(LocalCache.class);
    
        /**
         * 启动开始后延迟5秒执行时效策略
         */
        private static final int INITIAL_DELAY_TIME = 5;
        /**
         * 执行时效策略间隔时间
         */
        private static final int PERIOD_TIME = 5;
        /**
         * 本地缓存map
         */
        private static ConcurrentHashMap<String, Cache> store;
        /**
         * 执行时效策略线程池
         */
        private final static ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    
        /*
         * 静态代码块
         *
         * 初始化缓存map
         * 添加时效策略定时线程任务
         */
        static {
            store = new ConcurrentHashMap<>();
            executor.scheduleAtFixedRate(new Task(), INITIAL_DELAY_TIME, PERIOD_TIME, TimeUnit.SECONDS);
        }
    
        public static void put(String key, String value) {
            put(key, value, 0);
        }
    
        /**
         * 设置缓存
         * @param key 唯一key
         * @param value 值
         * @param expire 超时时间-单位(s/秒)
         */
        public static void put(String key, String value, long expire) {
            logger.info("添加缓存,key={}, value={}, expire={}秒", key, value, expire);
            if (expire > 0) {
                store.put(key, new Cache(value, expire));
            } else {
                store.put(key, new Cache(value));
            }
        }
    
        public static String get(String key) {
            Cache cache = store.get(key);
            if (cache == null) {
                return null;
            }
    
            if (cache.getExpire() > 0 && cache.getExpire() < System.currentTimeMillis()) {
                remove(key);
                return null;
            }
            return store.get(key).getValue();
        }
    
        private static void remove(String key) {
            Cache cache = store.remove(key);
            logger.info("懒惰淘汰策略: 移除超时失效数据, cache={}", cache);
        }
    
        private static void removeAll() {
            logger.info("定期删除策略: 开始执行, store={}", store);
            for (String key : store.keySet()) {
                Cache cache = store.get(key);
                if (cache.getExpire() > 0 && cache.getExpire() < System.currentTimeMillis()) {
                    store.remove(key);
                    logger.info("定期删除策略: 移除超时失效数据, key={}, value={}, time={}", key, cache.getValue(), cache.getExpire());
                }
            }
        }
    
        /**
         * 定时移除时效数据任务
         */
        private static class Task implements Runnable {
            @Override
            public void run() {
                try {
                    LocalCache.removeAll();
                } catch (Exception e) {
                    logger.info("定期删除策略异常", e);
                }
            }
        }
    
        /**
         * 本地缓存对象
         */
        @Data
        private static class Cache {
            private String value;
            private long expire = 0;
    
            Cache(String value, long expire) {
                this.value = value;
                this.expire = System.currentTimeMillis() + expire * 1000;
            }
    
            Cache(String value) {
                this.value = value;
            }
        }
    }
    
    

    联系方式

    如果对你有帮助,可以关注作者支持一下,每天会不定时回复留言(有任何问题都可以留言哦)。

    微信公众号
    浮生一境
    展开全文
  • java实现本地缓存

    千次阅读 2016-12-12 10:44:47
    本地缓存的作用是减少db或cache的查询次数。 使用场景为静态或者非敏感数据。 可以使用google的guava cache。 本文尝试自己写本地缓存。 import lombok.AllArgsConstructor; import lombok.Getter; import lombok....

    这里本地缓存的含义是 多个线程公用的一个静态的Map对象

    作用是减少db或cache的查询次数。

    使用场景为静态或者非敏感数据。

    也可以使用google的guava cache等


    缓存类

    import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.Setter;
    
    import java.util.HashMap;
    import java.util.Map;
    
    
    public class LocalCache {
    
        //缓存Map
        private static Map<String,CacheContent> map = new HashMap<>();
        private static  LocalCache localCache = new LocalCache();
    
        private LocalCache(){
        }
    
        public  String getLocalCache(String key) {
            CacheContent cc = map.get(key);
    
            if(null == cc) {
                return null;
            }
    
            long currentTime = System.currentTimeMillis();
    
            if(cc.getCacheMillis() > 0 && currentTime - cc.getCreateTime() > cc.getCacheMillis()) {
                //超过缓存过期时间,返回null
                map.remove(key);
                return null;
            } else {
                return cc.getElement();
            }
        }
    
        public void setLocalCache(String key,int cacheMillis,String value) {
            long currentTime = System.currentTimeMillis();
            CacheContent cc = new CacheContent(cacheMillis,value,currentTime);
            map.put(key,cc);
        }
    
        public static LocalCache getInStance(){
            return localCache;
        }
    
        @Getter
        @Setter
        @AllArgsConstructor
        class CacheContent{
            // 缓存生效时间
            private  int cacheMillis;
            // 缓存对象
            private String element;
            // 缓存创建时间
            private long createTime ;
    
        }
    
    
    
    }
    

    调用代码

    	//先查询本地缓存
                    String key ="testkey";
    		LocalCache localCache = LocalCache.getInStance();
    		String value = localCache.getLocalCache(key);
    
    		if(StringUtils.isBlank(value)) {
                            //从db或cache获取数据
    			value = RedisClient.get(key);
    			//设置本地缓存,生效时间为10秒
    			localCache.setLocalCache(key ,10000,value);
    		}





    展开全文
  • 对于缓存的作用不言而喻,可以提高查询...我将利用concurrentHashMap等集合容器实现一个本地缓存。1.基于concurrentHashMap的本地缓存本地缓存一般使用键值对方式的存储,那么在Java中肯定是选用map,由于concurr...

    对于缓存的作用不言而喻,可以提高查询效率,比去DB查询的速度要快。项目中我们经常会使用Nosql数据库,如Redis等做缓存。但是对于数据量很小的,访问非常频繁的,我们也可以存在本地缓存中。我将利用concurrentHashMap等集合容器实现一个本地缓存。

    1.基于concurrentHashMap的本地缓存。

    本地缓存一般使用键值对方式的存储,那么在Java中肯定是选用map,由于concurrentHashMap的线程安全性,所以就选择了这个。过期策略采用的定时清除,实现方式可以后台起一个线程去扫,也可以用定时器,本例子使用的是定时器。

    package com.example.demoproject.demo;

    import java.util.Map;

    import java.util.Timer;

    import java.util.TimerTask;

    import java.util.concurrent.ConcurrentHashMap;

    /**

    *

    * 基于concurrentHash的本地缓存工具类

    * 缓存删除基于timer定时器

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param null

    * @return

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public class CacheUtil {

    //默认大小

    private static final int DEFAULT_CAPACITY = 1024;

    // 最大缓存大小

    private static final int MAX_CAPACITY = 10000;

    //默认缓存过期时间

    private static final long DEFAULT_TIMEOUT = 3600;

    //1000毫秒

    private static final long SECOND_TIME = 1000;

    //存储缓存的Map

    private static final ConcurrentHashMap map;

    private static final Timer timer;

    static {

    map = new ConcurrentHashMap<>(DEFAULT_CAPACITY);

    timer = new Timer();

    }

    //私有化构造方法

    private CacheUtil() {

    }

    /**

    *

    * 缓存任务清除类

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param null

    * @return

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    static class ClearTask extends TimerTask {

    private String key;

    public ClearTask(String key) {

    this.key = key;

    }

    @Override

    public void run() {

    CacheUtil.remove(key);

    }

    }

    //==================缓存的增删改查

    /**

    *

    * 添加缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param key

    * @param object

    * @return void

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static boolean put(String key, Object object) {

    if (checkCapacity()) {

    map.put(key, object);

    //默认缓存时间

    timer.schedule(new ClearTask(key), DEFAULT_TIMEOUT);

    return true;

    }

    return false;

    }

    /**

    *

    * 添加缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param key

    * @param object

    * @param time_out :缓存过期时间:单位秒

    * @return void

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static boolean put(String key, Object object, int time_out) {

    if (checkCapacity()) {

    map.put(key, object);

    //默认缓存时间

    timer.schedule(new ClearTask(key), time_out * SECOND_TIME);

    }

    return false;

    }

    /**

    *

    * 判断容量大小

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param

    * @return boolean

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static boolean checkCapacity() {

    return map.size() < MAX_CAPACITY;

    }

    /**

    *

    * 批量增加缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param m

    * @param time_out

    * @return void

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static boolean put(Map m, int time_out) {

    if (map.size() + m.size() <= MAX_CAPACITY) {

    map.putAll(map);

    for (String key : m.keySet()) {

    timer.schedule(new ClearTask(key), time_out * SECOND_TIME);

    }

    return true;

    }

    return false;

    }

    /**

    *

    * 删除缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param key

    * @return void

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static void remove(String key) {

    map.remove(key);

    }

    /**

    *

    * 清除所有缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param

    * @return void

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public void clearAll() {

    if (map.size() > 0) {

    map.clear();

    }

    timer.cancel();

    }

    /**

    *

    * 获取缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param key

    * @return java.lang.Object

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static Object get(String key) {

    return map.get(key);

    }

    /**

    *

    * 是否包含某个缓存

    *

    * @author hejianfeng

    * @date 2019/10/5

    * @param key

    * @return boolean

    *

    * 修改记录

    * 版本号修订日期修改人bug编号修改内容

    * 1.0.0 2019/10/5 hejianfeng 新建

    *

    */

    public static boolean isContain(String key) {

    return map.contains(key);

    }

    }

    https://blog.csdn.net/weixin_39634532/article/details/102131226

    展开全文
  • packagedemo.shaw....importjava.util.LinkedHashMap;importjava.util.Map;importjava.util.concurrent.ScheduledExecutorService;importjava.util.concurrent.ScheduledThreadPoolExecutor;importjava.util.con...
  • 对于缓存的作用不言而喻,可以提高查询...我将利用concurrentHashMap等集合容器实现一个本地缓存。1.基于concurrentHashMap的本地缓存本地缓存一般使用键值对方式的存储,那么在Java中肯定是选用map,由于concurr...
  • 我们结合平常使用的Redis来想下,自己实现本地缓存需要考虑哪些因素呢,我这里总结了三点: 数据存储,基于Java实现的话我首先想到的是key-value结构的集合,如HashMap,并发环境下的话使用ConcurrentHashMap、有...
  • Java 实现本地缓存工具

    千次阅读 2016-12-01 12:11:40
    基本思路: 1、继承线程安全的ConcurrentHashMap  ...经测试:存储100万以内普通数据的频繁读写性能还可以,能满足中小型系统缓存需求,如果要多机器共享缓存,建议单独部署一个缓存服务器 /**  * @Title: Lo
  • Java-ConcurrentHashMap实现缓存,(缓存数量,过期时间,过期缓存清理)public class ConcurrentHashMapCacheUtils {private static Logger LOGGER = LoggerFactory.getLogger(ConcurrentHashMapCacheUtils.class);...
  • 一个简易的本地缓存实现首先定义一个缓存实体,包含三个属性放入缓存的时间戳,值以及过期时间/**** @author zhangwei_david* @version $Id: CacheEntity.java, v 0.1 2014年9月6日 下午2:07:00 Lenovo Exp $*//***...
  • java本地缓存实现

    千次阅读 2019-04-16 21:42:15
    java本地缓存实现
  • java web 项目中对频繁读取且相对稳定的...一个简易的本地缓存实现。首先数据一般都是有时效性的,不是放入缓存就一直存在,如果超过一定时间没有被使用则应当被清空,使其系统中不会使用到过期数据。下面是对本地...
  • Java简单实现本地缓存

    千次阅读 2019-04-21 08:04:58
    为了实现一致性hash算法(算法见https://blog.csdn.net/weixin_35971547/article/details/89427847),简单的编写了一个本地缓存实现类,记录在此,供大家参考。 LocalCache.java import org.slf4j.Logger; ...
  • java手动实现本地缓存

    2020-12-19 17:56:35
    本地缓存服务 key = 字符串 | value = 字符串 | expire = 秒(有效时间) put 添加缓存 get 读取缓存值 失效策略: 定期删除策略:启动1个线程,每2分钟扫描一次,超时数据移除 懒惰淘汰策略:每次...
  • 对于这些工具,我想大家肯定都非常熟悉,所以今天我们不聊它们,我们来聊一聊如何实现本地缓存。参考上面几种工具,要实现一个较好的本地缓存,平头哥认为要从以下三个方面开始。1、存储集合的选择实现本地缓存,...
  • 一个简易的本地缓存实现?首先定义一个缓存实体,包含三个属性?放入缓存的时间戳,值以及过期时间?class="java">/**** @author zhangwei_david* @version $Id: CacheEntity.java, v 0.1 2014年9月6日 下午2:07:00 ...
  • 实现 Java 本地缓存

    2019-11-06 10:45:17
    对于这些工具,我想大家肯定都非常熟悉,所以今天我们不聊它们,我们来聊一聊如何实现本地缓存。参考上面几种工具,要实现一个较好的本地缓存,平头哥认为要从以下三个方面开始。 1、存储集合的选择 实现本地缓存,...
  • 在Javaweb 项目中对频繁读取且相对稳定...一个简易的本地缓存实现。首先数据一般都是有时效性的,不是放入缓存就一直存在,如果超过一定时间没有被使用则应当被清空,使其系统中不会使用到过期数据。下面是对本地缓...
  • 本地缓存机制,利用java.util.concurrent,很好的管理本地内存存储的对象内容。创建属性:/*** 具体内容存放的地方*/private ConcurrentHashMap[] caches;/*** 超期信息存储*/private ConcurrentHashMapexpiryCache;...
  • 本地缓存实现大概思路,单例模式创建本地缓存实例 + 定时器定时扫描缓存是否过期代码如下package webapp.cache;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;/*** @Author:...
  • 一般我们是通过key从缓存中读取value,如果读取不到则读取数据库,将数据库读取到的数据再放入缓存中。首先数据一般都是有一定的时效性的,也就是说,不是放入缓存中就一直都会存在,如果超过一定时间没有被使用则...
  • 对于这些工具,我想大家肯定都非常熟悉,所以今天我们不聊它们,我们来聊一聊如何实现本地缓存。参考上面几种工具,要实现一个较好的本地缓存,平头哥认为要从以下三个方面开始。1、存储集合的选择实现本地缓存,...
  • 对于这些工具,我想大家肯定都非常熟悉,所以今天我们不聊它们,我们来聊一聊如何实现本地缓存。参考上面几种工具,要实现一个较好的本地缓存,平头哥认为要从以下三个方面开始。1、存储集合的选择实现本地缓存,...
  • java实现本地数据缓存

    2021-04-16 17:59:28
    @Description 模版条目列表缓存 @Date 2021/4/13 16:14 @Author lichengshuai */ public class IECItemCacheUtil { private static ConcurrentMap<String, List> IEC_ITEM_DATA = Maps.newConcurrentMap()...
  • java web 项目中对频繁读取且相对稳定的...一个简易的本地缓存实现。首先数据一般都是有时效性的,不是放入缓存就一直存在,如果超过一定时间没有被使用则应当被清空,使其系统中不会使用到过期数据。下面是对本地...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 949
精华内容 379
关键字:

java实现本地缓存

java 订阅