设计

存在两个集合ReadOnlyMap、ReadWriteMap。
读请求，全部是从ReadOnlyMap里面，如果里面没有，就从ReadWriteMap中找。如果ReadWriteMap也没有就去服务注册表中拿。
ReadOnlyMap，大量的线程并发的读服务注册表的数据，在这里是不需要加锁的，大家直接读，不需要加读锁，就没有大量的读锁和写锁的冲突了。
只有在ReadOnlyMap里面没数据的时候，此时会加一个synchronized锁，只有一个线程可以去找ReadWriteMap，去找服务注册表的数据，此时会加服务注册表的读锁，但是找到了数据，填充完了ReadWriteMap两级缓存之后，就会释放synchronized锁，其他线程就可以直接读缓存里的数据了。
将服务注册表的读锁，降低到了，很少的频率，某个线程发现缓存里没数据，要直接读取原服务注册表的数据的时候，才会加读锁。
如果更新数据之后，就会过期掉ReadWriteMap的一些数据，清空缓存。

实现

  1. public class ServiceRegistryCache {
  4.     private static final ServiceRegistryCache instance = new ServiceRegistryCache();
  6.     /**
  7.      * 缓存数据同步间隔
  8.      */
  9.     private static final Long CACHE_MAP_SYNC_INTERVAL = 30 * 1000L;
  10.     /**
  11.      * 缓存操作类型key
  12.      */
  13.     public static class CacheKey {
  14.         /**
  15.          * 全量注册表的key
  16.          */
  17.         public static final String FULL_SERVICE_REGISTRY = "full_service_registry";
  18.         /**
  19.          * 增量注册表的key
  20.          */
  21.         public static final String DELTA_SERVICE_REGISTRY = "DELTA_service_registry";
  22.     }
  24.     /**
  25.      * 实际注册表
  26.      */
  27.     private ServiceRegistry registry = ServiceRegistry.getInstance();
  28.     /**
  29.      * 只读缓存
  30.      */
  31.     private Map<String, Object> readOnlyMap = new HashMap<String, Object>();
  33.     /**
  34.      * 读写缓存
  35.      */
  36.     private Map<String, Object> readWriteMap = new HashMap<String, Object>();
  38.     /**
  39.      * 缓存表同步后台线程
  40.      */
  41.     private CacheMapSyncDaemon cacheMapSyncDaemon;
  43.     /**
  44.      * 内部锁
  45.      */
  46.     private Object key = new Object();
  48.     /**
  49.      * 读写锁
  50.      */
  51.     private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  52.     private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
  53.     private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
  54.     /**
  55.      * 构造函数
  56.      */
  57.     private ServiceRegistryCache() {
  58.         //启动缓存数据的后台线程
  59.         this.cacheMapSyncDaemon = new CacheMapSyncDaemon();
  60.         this.cacheMapSyncDaemon.setDaemon(true);
  61.         this.cacheMapSyncDaemon.start();
  62.     }
  64.     /**
  65.      * 根据缓存key获取数据
  66.      * @param cacheKey
  67.      * @return
  68.      */
  69.     public Object get(String cacheKey) {
  70.         try {
  71.             readLock.lock();
  72.             //这里获取数据的时候就不加锁，也就不存在和写锁互斥然后等待了。
  73.             Object cacheValue = readOnlyMap.get(cacheKey);
  74.             if (cacheValue == null) {
  75.                 synchronized (key) {
  76.                     if ((cacheValue = readOnlyMap.get(cacheKey)) == null) {
  77.                         cacheValue = readWriteMap.get(cacheKey);
  78.                         if (cacheValue == null) {
  79.                             cacheValue = getCacheValue(cacheKey);
  80.                             readWriteMap.put(cacheKey,cacheValue);
  81.                             readOnlyMap.put(cacheKey,cacheValue);
  82.                         }
  83.                         readOnlyMap.put(cacheKey,cacheValue);
  84.                     }
  85.                 }
  86.             }
  87.             return cacheValue;
  88.         } finally {
  89.             readLock.unlock();
  90.         }
  91.     }
  93.     /**
  94.      *获取实际的缓存数据（就是从原注册表中拿）
  95.      * @param cacheKey
  96.      * @return
  97.      */
  98.     public Object getCacheValue(String cacheKey) {
  99.         try {
  100.             registry.readLock();
  101.             if (CacheKey.FULL_SERVICE_REGISTRY.equals(cacheKey)) {
  102.                 return new Applications(registry.getRegistry());
  103.             } else if (CacheKey.DELTA_SERVICE_REGISTRY.equals(cacheKey)) {
  104.                 return registry.getDeltaRegistry();
  105.             }
  106.         } finally {
  107.             registry.readUnlock();
  108.         }
  109.         return null;
  110.     }
  112.     /**
  113.      * 过期掉对应缓存
  114.      */
  115.     public void invalidate() {
  116.         synchronized (readOnlyMap) {
  117.             readWriteMap.remove(CacheKey.FULL_SERVICE_REGISTRY);
  118.             readWriteMap.remove(CacheKey.DELTA_SERVICE_REGISTRY);
  119.         }
  120.     }
  122.     /**
  123.      * 返回单例
  124.      * @return
  125.      */
  126.     public static ServiceRegistryCache getInstance() {
  127.         return instance;
  128.     }
  130.     /**
  131.      * cachemap同步后台线程
  132.      */
  133.     class CacheMapSyncDaemon extends Thread {
  134.         @Override
  135.         public void run() {
  136.             while (true) {
  137.                 try {
  138.                     synchronized (key) {
  139.                         if (readWriteMap.get(CacheKey.FULL_SERVICE_REGISTRY) == null) {
  140.                             try {
  141.                                 writeLock.lock();
  142.                                 readOnlyMap.put(CacheKey.FULL_SERVICE_REGISTRY,null);
  143.                             } finally {
  144.                                 writeLock.unlock();
  145.                             }
  146.                         }
  147.                         if (readWriteMap.get(CacheKey.DELTA_SERVICE_REGISTRY) == null) {
  148.                             try {
  149.                                 writeLock.lock();
  150.                                 readOnlyMap.put(CacheKey.DELTA_SERVICE_REGISTRY,null);
  151.                             } finally {
  152.                                 writeLock.unlock();
  153.                             }
  154.                         }
  155.                     }
  156.                     Thread.sleep(CACHE_MAP_SYNC_INTERVAL);
  157.                 } catch (InterruptedException e) {
  158.                     e.printStackTrace();
  159.                 }
  160.             }
  161.         }
  162.     }
  163. }

分析一下具体优化了什么？
获取缓存数据，Object cacheValue = readOnlyMap.get(cacheKey);这里就加了个读锁锁的，别看那有个readLock这个是保证在清理缓存的时候读到的数据是准确的。更多时间是没有影响，同时定时清理缓存是每30秒来加写锁，争用的频率很低了。可以说是80%以上读注册表数据的时候都是没有冲突的，因此就很快。

image.png
当系统启动的时候，这块会从原始注册表中拉取数据放到缓存表中，这里用synchronized串行化了一下保证并发安全。之后大量读请求都是读的readOnlyMap这里就一个读锁影响是非常小的，最多就是和同步缓存表数据的后台线程那里冲突一下，而且是每隔30秒，同时是“有可能”会冲突。
之前直接对原始表获取数据的时候，那时候的读操作跟服务注册，服务下线，服务定时检查下线的写锁就会有冲突，冲突频率要比从缓存中拿要高得多。
image.png