java实现缓存框架

阳光穿透心脏的1/2处 2022-05-19 23:22 215阅读 0赞

#### **缓存的原理** ####

#####         外存： 外储存器是指除计算机内存及CPU缓存以外的储存器，此类储存器一般断电后仍然能保存数据。常见的外存储器有硬盘、软盘、光盘、U盘等，一般的软件都是安装在外存中（windows系统指的是CDEF盘, Linux系统指的是挂载点）。 #####

#####         内存：内存是计算机中重要的部件之一，它是与CPU进行沟通的桥梁。计算机中所有程序的运行都是在内存中进行的，因此内存的性能对计算机的影响非常大。内存(Memory)也被称为内存储器，其作用是用于暂时存放CPU中的运算数据，以及与硬盘等外部存储器交换的数据。只要计算机在运行中，CPU就会把需要运算的数据调到内存中进行运算，当运算完成后CPU再将结果传送出来，内存的运行也决定了计算机的稳定运行，此类储存器一般断电后数据就会被清空。 #####

#####         缓存：缓存是用来协调CPU与主存之间存取速度的差异而设置的。一般情况下，CPU的工作速度高，但内存的工作速度相对较低，为了解决这个问题，通常使用高速缓存，高速缓存的存取速度介于CPU和主存之间。系统将一些CPU在近几个时间段经常访问的内容存入高速缓冲，当CPU需要使用数据时，先在高速缓存中找，如果找到，就不必访问内存了，找不到时，再找内存，这样就在一定程度上缓解了由于主存速度低造成的CPU“停工待料”的情况。 #####

#####     缓存就是把一些外存上的数据保存到内存上而已，怎么保存到内存上呢，我们运行的所有程序，里面的变量值都是放在内存上的，所以说如果要想使一个值放到内存上，实质就是在获得这个变量之后，用一个生存期较长的变量存放你想存放的值，在java中一些缓存一般都是通过map集合来做的。 #####

简单讲就是，如果某些资源或者数据会被频繁的使用，而这些资源或数据存储在系统外部，比如数据库、硬盘文件等，那么每次操作这些数据的时候都从数据库或者硬盘上去获取，速度会很慢，会造成性能问题。  
　 一个简单的解决方法就是：把这些数据缓存到内存里面，每次操作的时候，先到内存里面找，看有没有这些数据，如果有，那么就直接使用，如果没有那么就获取它，并设置到缓存中，下一次访问的时候就可以直接从内存中获取了。从而节省大量的时间，当然，缓存是一种典型的空间换时间的方案。

##### **基本概念讲的差不多了, 现在用java来实现一个基本的缓存框架：** #####

**思路：**

1. 先得有一个缓存实体类

2. 考虑用map作为存储容器

3. 设置缓存有效时间, 当时间失效时, 清除缓存数据

4. 用线程的方式实现简单的缓存框架

**代码实现：**

package com.cache.demo;
    
    /**
     * @Description 缓存实体类
     * @author ShengLiu
     * @date 2018/7/8
     */
    public class Cache {
        public Cache(){
    
        }
    
        public Cache(String key, Object value, Long timeOut){
            super();
            this.key = key;
            this.value = value;
            this.timeOut = timeOut;
        }
    
        /**
         * key
         */
        private String key;
        /**
         * 缓存数据
         */
        private Object value;
        /**
         * 超时时间
         */
        private Long timeOut;
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public Object getValue() {
            return value;
        }
    
        public void setValue(Object value) {
            this.value = value;
        }
    
        public Long getTimeOut() {
            return timeOut;
        }
    
        public void setTimeOut(Long timeOut) {
            this.timeOut = timeOut;
        }
    
        @Override
        public String toString() {
            return "Cache{" +
                    "key='" + key + '\'' +
                    ", value=" + value +
                    ", timeOut=" + timeOut +
                    '}';
        }
    
    }

package com.cache.demo;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @Description 缓存map
     * @author ShengLiu
     * @date 2018/7/8
     */
    public class CacheManager {
        /**
         * 存放缓存数据
         */
        private Map<String, Object> cacheMap = new HashMap<>();
    
        /**
         * @Description 往缓存中存数据
         * @author ShengLiu
         * @date 2018/7/8
         * @param key
         * @param value
         * @return void
         */
        public synchronized void put(String key, Object value){
            put(key, value, null);
        }
    
        /**
         * @Description 往缓存中存数据
         * @author ShengLiu
         * @date 2018/7/8
         * @param key
         * @param value
         * @param timeout
         * @return void
         */
        public synchronized void put(String key, Object value, Long timeout){
            if (value == null){
                return;
            }
            Cache cache = new Cache();
            cache.setKey(key);
            cache.setValue(value);
            if (timeout != null){
                cache.setTimeOut(timeout + System.currentTimeMillis());
            }
            cache.setValue(value);
            cacheMap.put(key, cache);
        }
    
        /**
         * @Description 删除
         * @author ShengLiu
         * @date 2018/7/8
         * @param key
         * @return void
         */
        public synchronized void deleteCache(String key){
            cacheMap.remove(key);
        }
    
        /**
         * @Description 获取缓存中的数据
         * @author ShengLiu
         * @date 2018/7/8
         * @param key
         * @return java.lang.Object
         */
        public synchronized Object get(String key){
            Cache cache = (Cache) cacheMap.get(key);
            Object obj = null;
            if (cache != null){
                obj = cache.getValue();
            }
            return obj;
        }
    
        /**
         * @Description 检查数据是否在有效期内
         * @author ShengLiu
         * @date 2018/7/8
         * @param
         * @return void
         */
        public synchronized void checkValidityData(){
            for (String key: cacheMap.keySet()){
                Cache cache = (Cache) cacheMap.get(key);
                Long timeOut = cache.getTimeOut();
                if(timeOut == null){
                    return;
                }
                long currentTime = System.currentTimeMillis();
                long endTime = timeOut;
                long resultTime = (currentTime - endTime);
                if (resultTime > 0){
                    System.out.println("清除: " + key);
                    cacheMap.remove(key);
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            final CacheManager cacheManager = new CacheManager();
            cacheManager.put("jj", "林俊杰", 5000L);
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            scheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    cacheManager.checkValidityData();
                }
            }, 5000, TimeUnit.MILLISECONDS);
            Thread.sleep(5000);
            System.out.println("保存成功");
            System.out.println(cacheManager.get("jj"));
        }
    
    }