1、本地jvm缓存

缓存是将数据在整个程序生命周期中存储的内存
作用：

  • 能够提升获取数据的效率，避免IO读取耗时操作。
  • 被大量的读取，更新频率低。
  • 经常变化，但是不会被持久化的。

方式：
使用static关键字开辟内存与搜索时间复杂度O（1）的hashmap来存储数据提高读取效率；然后实现相对应的缓存写入，更新，读取，删除等逻辑

spring-boot提供了一个spring-boot-devtools包，其作用就是在不重启服务的情况下将服务重新部署到服务器上。原理是使用两个类加载器，一个用于加载变化的类文件，一个用于加载未发生变化的类文件，直接对未改变的类文件进行加载极大的提高整个效率。
或者使用Redis作为缓存。

HashMap缺点

  1. 没有缓存大小的设置，无法限定缓存体的大小以及存储数据的限制
  2. 没有弱键引用，在内存占用吃紧的情况下，JVM是无法回收的

阿里笔试题在规定的时间内，用hashMap实现一个缓存工具类

要点：

  • 不可变对象
  • 单例
  • 线程安全
  • 回收失效数据
  • 垃圾回收
  • 缓存大小
  • LRU算法
    代码如下
  1. /**
  2.  * Created by zhangshukang on 2018/8/1.
  3.  */
  4. public class CacheManager {
  6.     private CacheManager() {
  7.     }
  9.     //是否开启清除失效缓存
  10.     private volatile Boolean clearExpireCacheEnable = true;
  12.     //缓存失效时间
  13.     private long cacheTimeout = 12 * 60 * 60 * 1000L;
  15.     //缓存使用记录
  16.     private static LinkedList<Object> cacheUseRecord = new LinkedList<>();
  18.     //可缓存最大数量
  19.     private static Integer MAX_CACHE_SIZE = 80;
  21.     //重入读写锁
  22.     private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
  23.     private static Lock writeLock = reentrantReadWriteLock.writeLock();
  24.     private static Lock readLock = reentrantReadWriteLock.readLock();
  26.     private final static Map<Object, CacheEntry> cacheEntryMap = new ConcurrentHashMap<>();
  29.     private void init() {
  30.         initClearTask();
  31.     }
  33.     //自定义缓存失效时间
  34.     private void init(long cacheTimes) {
  35.         this.cacheTimeout = cacheTimes;
  36.         initClearTask();
  37.     }
  39.     private void initClearTask() {
  40.         //启动清除失效缓存数据
  41.         if (clearExpireCacheEnable) {
  42.             new ClearCacheTask().start();
  43.         }
  44.     }
  47.     private static CacheManager getCacheManagerInstance() {
  48.         return CacheManagerFactory.CACHE_MANAGER;
  49.     }
  51.     private static class CacheManagerFactory {
  52.         private static final CacheManager CACHE_MANAGER = new CacheManager();
  53.     }
  55.     private class ClearCacheTask extends Thread {
  57.         ClearCacheTask() {
  58.             super.setName("clear cache task start ...");
  59.         }
  61.         @Override
  62.         public void run() {
  63.             while (clearExpireCacheEnable) {
  64.                 try {
  65.                     long now = System.currentTimeMillis();
  67.                     //定时清理
  68.                     try {
  69. //                        Thread.sleep(1000 * 60 * 60);
  70.                     } catch (Exception e) {
  71.                         e.printStackTrace();
  72.                     }
  74.                     cacheEntryMap.keySet().stream().forEach(key -> {
  75.                         try {
  76.                             writeLock.lock();
  78.                             //判断使用记录中的key是否已经被LRU清除
  79.                             if (!cacheUseRecord.contains(key)) {
  80.                                 return;
  81.                             }
  83.                             CacheEntry entry = cacheEntryMap.get(key);
  84.                             if (now - entry.lastTouchTime >= cacheTimeout) {
  85.                                 cacheEntryMap.remove(key);
  86.                                 cacheUseRecord.remove(key);
  87.                                 System.out.println("清理缓存key：" + key);
  89.                             }
  90.                         } finally {
  91.                             writeLock.unlock();
  92.                         }
  93.                     });
  95.                     Thread.sleep(cacheTimeout);
  96.                 } catch (Exception e) {
  97.                     e.printStackTrace();
  98.                 }
  99.             }
  100.         }
  101.     }
  104.     //失效时间，value，entry，可根据需要决定是否继承Map.Entry<K,V>
  105.     @Data
  106.     private class CacheEntry {
  107.         long lastTouchTime;
  109.         Object value;
  111.         CacheEntry(Object value) {
  112.             super();
  113.             this.value = value;
  114.             this.lastTouchTime = System.currentTimeMillis();
  115.         }
  116.     }
  119.     public Object get(Object key) {
  121.         readLock.lock();
  122.         CacheEntry entry = null;
  123.         try {
  124.             entry = cacheEntryMap.get(key);
  125.         } finally {
  126.             readLock.unlock();
  127.         }
  128.         if (null == entry)
  129.             return null;
  131.         //更新缓存访问时间
  132.         touchCache(entry);
  133.         //更新使用记录
  134.         touchUseRecord(key);
  136.         return entry == null ? null : entry.value;
  137.     }
  139.     //更新缓存访问时间
  140.     public static void touchCache(CacheEntry entry) {
  141.         writeLock.lock();
  142.         try {
  143.             entry.setLastTouchTime(System.currentTimeMillis());
  144.         } finally {
  145.             writeLock.unlock();
  146.         }
  148.     }
  150.     //更新缓存使用记录
  151.     public static void touchUseRecord(Object key) {
  153.         writeLock.lock();
  154.         try {
  155.             //删除使用记录
  156.             cacheUseRecord.remove(key);
  157.             //新增使用记录到首位
  158.             cacheUseRecord.add(0, key);
  159.         } finally {
  160.             writeLock.unlock();
  161.         }
  162.     }
  165.     public Object put(Object key, Object value) throws Exception {
  167.         //判断缓存大小是否够用，否则根据LRU删除最久未使用的元素
  168.         if (cacheEntryMap.size() > MAX_CACHE_SIZE) {
  169.             deleteLRU();
  170.         }
  171.         if (cacheEntryMap.size() > MAX_CACHE_SIZE) {
  172.             throw new Exception("缓存大小超出限制");
  173.         }
  175.         CacheEntry entry = new CacheEntry(value);
  177.         writeLock.lock();
  178.         try {
  179.             cacheEntryMap.put(key, entry);
  180.             cacheUseRecord.add(0, key);
  181.         } finally {
  182.             writeLock.unlock();
  183.         }
  184.         return value;
  185.     }
  188.     /**
  189.      * 删除最近最久未使用的缓存
  190.      */
  191.     public static void deleteLRU() {
  193.         Object cacheKey = null;
  194.         writeLock.lock();
  195.         try {
  196.             cacheKey = cacheUseRecord.remove(cacheUseRecord.size() - 1);
  197.             cacheEntryMap.remove(cacheKey);
  198.             System.out.println("LRU清除元素key：" + cacheKey);
  199.         } finally {
  200.             writeLock.unlock();
  201.         }
  202.     }
  204.     public static void delete(Object key) {
  206.         if (null == key)
  207.             return;
  209.         writeLock.lock();
  210.         try {
  211.             cacheEntryMap.remove(key);
  212.             cacheUseRecord.remove(key);
  213.         } finally {
  214.             writeLock.unlock();
  215.         }
  216.     }
  219.     public static void clear() {
  221.         writeLock.lock();
  222.         try {
  223.             cacheEntryMap.clear();
  224.             cacheUseRecord.clear();
  225.         } finally {
  226.             writeLock.unlock();
  227.         }
  228.     }
  231.     public static void main(String[] args) throws Exception {
  232.         CacheManager cacheManager = CacheManager.getCacheManagerInstance();
  233.         cacheManager.init(0);
  235.         for (int i = 0; i < 200; i++) {
  236.             cacheManager.put(i + "", i);
  237.         }
  238.     }
  239. }

2、JVM缓存更新问题

不允许重启服务情况下
其实方案也很多，可以使用用zookeeper，也可以使用分布式配置，这里是比较推荐使用分布式配置中心的，可以将这些数据配置到分布式配置中心去！