Java-ConcurrentHashMap实现缓存、异步

青旅半醒 2021-09-16 03:04 251阅读 0赞

# Java-ConcurrentHashMap实现缓存、异步 #

### MyCache.java ###

package cn.pangpython.test.cache;
    
    /**
     * Created by pangPython on 2017/9/25.
     *
     * 缓存实体类
     */
    public class MyCache {
        private String sessionID;//key
        private Object cacheObj;//value
        private long lastAccessTime;//最后访问时间
    
        public MyCache(String sessionID, Object cacheObj) {
            this.sessionID = sessionID;
            this.cacheObj = cacheObj;
        }
    
        public MyCache(String sessionID, Object cacheObj, long lastAccessTime) {
            this.sessionID = sessionID;
            this.cacheObj = cacheObj;
            this.lastAccessTime = lastAccessTime;
        }
    
        public String getSessionID() {
            return sessionID;
        }
    
        public void setSessionID(String sessionID) {
            this.sessionID = sessionID;
        }
    
        public Object getCacheObj() {
            return cacheObj;
        }
    
        public void setCacheObj(Object cacheObj) {
            this.cacheObj = cacheObj;
        }
    
        public long getLastAccessTime() {
            return lastAccessTime;
        }
    
        public void setLastAccessTime(long lastAccessTime) {
            this.lastAccessTime = lastAccessTime;
        }
    }

### CacheManager.java ###

package cn.pangpython.test.cache;
    
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * Created by pangPython on 2017/9/25.
     */
    public class CacheManager {
        private ConcurrentHashMap<String,MyCache> cacheContainer = null;
        private static volatile CacheManager m_cacheManager = null;
        private long timeout;
    
    
        public static CacheManager getInstance() {
            if(m_cacheManager == null){
                synchronized (CacheManager.class){
                    if(m_cacheManager == null){
                        m_cacheManager = new CacheManager(1000*60*30);
                    }
                }
            }
            return m_cacheManager;
        }
    
        private CacheManager(long timeout) {
            this.timeout = timeout;
            cacheContainer = new ConcurrentHashMap<>();
            CacheCleaner cacheCleanerThread = new CacheCleaner();
            cacheCleanerThread.start();
        }
    
        /**
         * 访问缓存
         * 每一次访问把最后访问时间改成当前时间
         *
         * @param key
         * @return
         */
        public MyCache getCache(String key){
            MyCache myCache = cacheContainer.get(key);
            myCache.setLastAccessTime(System.currentTimeMillis());
            cacheContainer.put(key,myCache);
            return myCache;
        }
    
        /**
         * 添加缓存
         *
         * 默认最后访问时间为当期时间
         * @param key
         * @param value
         */
        public void setCache(String key,MyCache value){
      //      System.out.println("key:"+key);
    //        System.out.println("value:"+value);
            MyCache myCache = new MyCache(key,value.getCacheObj());
            myCache.setLastAccessTime(System.currentTimeMillis());
            cacheContainer.put(key,myCache);
        }
    
        /**
         * 缓存定时清理线程
         *
         */
        class CacheCleaner extends Thread{
    
            @Override
            public void run() {
                while(true){
                    /**
                     * 30分钟执行一次清理
                     *
                     */
                    try {
                        Thread.sleep(1000*60*30);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    for (Map.Entry<String,MyCache> entry:cacheContainer.entrySet() ) {
                        String sessionID = entry.getKey();
                        MyCache myCache = entry.getValue();
                        if(System.currentTimeMillis() - myCache.getLastAccessTime() >= timeout){
                            cacheContainer.remove(sessionID);
                        }
                    }
    
    
    
                }
            }
        }
    }

### CacheTest.java ###

package cn.pangpython.test.cache;
    
    import java.util.Random;
    
    /**
     * Created by pangPython on 2017/9/25.
     */
    public class CacheTest {
        public static void main(String[] args){
            /**
             * 比较好的使用场景就是：网络请求的状态下，请求过来，直接返回，然后开启线程操作，修改结果集，供上层轮询调用，实现异步。
             *
             */
            CacheManager cacheManager = CacheManager.getInstance();
            String sessionID = "test_sessionid";
            Integer random_num = new Random().nextInt();
            System.out.println(random_num);
            MyCache myCache = new MyCache(sessionID,random_num);
            cacheManager.setCache(sessionID,myCache);
    
            //休眠3秒
            try {
                Thread.sleep(1000*3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println(cacheManager.getCache(sessionID).getCacheObj().toString());
    
    
        }
    }

[https://blog.csdn.net/u012995856/article/details/78090818][https_blog.csdn.net_u012995856_article_details_78090818]

[https_blog.csdn.net_u012995856_article_details_78090818]: https://blog.csdn.net/u012995856/article/details/78090818