java_缓存

缓存可以分为2种：

       1，文件缓存（把数据以文件的形式存储到本地硬盘）

       2，内存缓存（实现一个类中静态Map,对这个Map进行常）

下面我们来实现一个内存缓存：

import java.util.LinkedHashMap;
import java.util.Map;
/**
 * 
 * 
 * 基于继承方式扩展LinkedHashMap
 * 
 * 1，重新构造
 * 
 * 2，重写删除老数据方法
 * 
 * **/
public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
    
      private final int MAX_CACHE_SIZE;
     /**
      * 自定义构造方法
      * 
      * LinkedHashMap 有5种构造方法；
      * 1，空构造  初始化容量为16  加载因子为0.75
      * 2，带初始化容量的构造
      * 3，带初始化容量和加载因子的构造  默认加载因子是0.75
      * 4，带初始化容量 构造原子 排序模式的构造   排序模式如果是true则通过访问顺序排序   如果是false 则为插入顺序
      * 5，构造一个映射关系与指定映射相同的插入顺序 LinkedHashMap 实例
      * **/
      public LRULinkedHashMap(int cacheSize) {
            super((int) Math.ceil(cacheSize / 0.75) + 1, 0.8f, true);
            MAX_CACHE_SIZE = cacheSize;
        }     
      
      //LinkedHashMap自带的判断是否删除最老的元素方法，默认返回false，即不删除老数据  我们要做的就是重写这个方法，当满足一定条件时删除老数据
      @Override
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > MAX_CACHE_SIZE;
        }
      
      @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            for (Map.Entry<K, V> entry : entrySet()) {
                sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
            }
            return sb.toString();
        }
}

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Description
 *  java 缓存简单那实现 
 *  简介： 
 *              1，通过利用java内存管理的static特性，采用 new static  Map来在内存中存储信息
 * 
 *              2，内存类缓存的 存 取 更新 释放 同步策略 存： add 取：get 更新： 释放： 同步：
 * 
 *              3，缓存控制的多线程实现
 * 
 * 释放策略：
 *               1，LRU last recently used 最近最少使用 2，FIFO first input first output 先进先出
 * 
 * **/
public class CacheManager {
    
    // 我们通过单例模式来实现实例化cache的map
    private static CacheManager instance = null;
    private static LRULinkedHashMap LRUMap = null;
    private static LinkedHashMap FIFOMap = null;
    
    public static CacheManager getInstance() {
        if (instance == null) {
            synchronized (CacheManager.class) {
                if (instance == null) {
                    instance = new CacheManager();
                }
            }
        }
        return instance;
    }
    private CacheManager() {}
    
    //获得LRU模式的存储map
    public LRULinkedHashMap<Object,Object> getLRUCacheMap(int maxCacheSize){
        synchronized(LRUMap){
           if(LRUMap == null){
               LRUMap = new LRULinkedHashMap<Object,Object>(maxCacheSize);
           }    
        }
         
         return LRUMap;
    }
    //获得FIFO模式的map
   public LinkedHashMap getFIFOCacheMap(){
       synchronized(FIFOMap){
           if(FIFOMap == null){
                 FIFOMap = new LinkedHashMap<Integer, String>() {
                     @Override
                     protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
                     return size() > 100;
                     }
           };
           }
       }
       
      return FIFOMap;
     }
}

其实缓存主要的目的就是以空间来换时间；通过内存的快速读写来替代我们的直接读写；

在实现缓存的时主要注意点：

         1，何时需要实现缓存

         2，缓存的大小控制

         3，缓存的数据添加   删除   更新

         4，多线程下地缓存实现

通过以上的代码：

     我们就可以带着问题去学习　　EHCache   　　OSCache 等缓存框架！

    问题：  什么是缓存？  缓存的实中得策略？（添加，更新）   我么改怎么去选择一个适合我们的缓存框架

                如何评价一个缓存的好坏还是要看自己的业务逻辑结合框架的实现策略进行匹配！