缓存的原理

        外存： 外储存器是指除计算机内存及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"));
    }

}