Redis缓存异常常用解决方案总结

 public class MyCache{
 ​
     private ConcurrentHashMap<String, String> map;
 ​
     private CountDownLatch countDownLatch;
 ​
     private AtomicInteger atomicInteger;
 ​
     public MyCache(ConcurrentHashMap<String, String> map, CountDownLatch countDownLatch,
                    AtomicInteger atomicInteger) {
         this.map = map;
         this.countDownLatch = countDownLatch;
         this.atomicInteger = atomicInteger;
     }
 ​
     public String get(String key){
 ​
         String value = map.get(key);
         if (value != null){
             System.out.println(Thread.currentThread().getName()+"\t 线程获取value值 value="+value);
             return value;
         }
         // 如果没获取到值
         // 首先尝试获取token，然后去查询db，初始化化缓存；
         // 如果没有获取到token，超时等待
         if (atomicInteger.compareAndSet(0,1)){
             System.out.println(Thread.currentThread().getName()+"\t 线程获取token");
             return null;
         }
 ​
         // 其他线程超时等待
         try {
             System.out.println(Thread.currentThread().getName()+"\t 线程没有获取token，等待中。。。");
             countDownLatch.await();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         // 初始化缓存成功，等待线程被唤醒
         // 等待线程等待超时，自动唤醒
         System.out.println(Thread.currentThread().getName()+"\t 线程被唤醒，获取value ="+map.get("key"));
         return map.get(key);
     }
 ​
     public void put(String key, String value){
 ​
         try {
             Thread.sleep(2000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         map.put(key, value);
 ​
         // 更新状态
         atomicInteger.compareAndSet(1, 2);
 ​
         // 通知其他线程
         countDownLatch.countDown();
         System.out.println();
         System.out.println(Thread.currentThread().getName()+"\t 线程初始化缓存成功！value ="+map.get("key"));
     }
 ​
 }
 ​
 public  class MyThread implements Runnable{
 ​
     private MyCache myCache;
 ​
     public MyThread(MyCache myCache) {
         this.myCache = myCache;
     }
 ​
     @Override
     public void run() {
         String value = myCache.get("key");
         if (value == null){
             myCache.put("key","value");
         }
 ​
     }
 }
 ​
 public class CountDownLatchDemo {
     public static void main(String[] args) {
 ​
         MyCache myCache = new MyCache(new ConcurrentHashMap<>(), new CountDownLatch(1), new AtomicInteger(0));
 ​
         MyThread myThread = new MyThread(myCache);
 ​
         ExecutorService executorService = Executors.newFixedThreadPool(5);
         for (int i = 0; i < 5; i++) {
             executorService.execute(myThread);
         }
     }
 }