基于synchronized 或 ReadWriteLock实现 简单缓存机制

 package cn.xxx.xxx;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;

 public class CacheDemo_My {

     public static void main(String[] args) {
         // 内部类 实例化时需要在 内部类前加static 关键字
         final CacheClass cacheClass = new CacheClass();
         for (int i = 0; i < 10; i++) {
             new Thread(new Runnable() {

                 @Override
                 public void run() {
                     Object valueObject = cacheClass.getData("1");
                     System.out.println(Thread.currentThread().getName() + " : " + valueObject);
                 }
             }).start();
         }
     }

     static class CacheClass {
         private Map<String, Object> cacheMap = new HashMap<String, Object>();

         /**
          * 1.0 没有考虑并发 问题： 从数据库查了两次
          * 从数据库查询数据！
          * 从数据库查询数据！
          *  Thread-1 : null 为什么是null，并发了，过程如 Thread-0 所示
          *  Thread-2 : aaa
          *  Thread-0 :null  为什么是null，因为第一次读取map中没有值返回null，而cacheMap.put(key, "aaa")后
          *             并没有重新赋值给object  所以是null
          *             解决方案是 直接从cacheMap.get(key) 中获取，不要中间环节 object，这里我就不改了
          *  Thread-3 : aaa
          *  Thread-4 : aaa
          *  Thread-5 : aaa
          *  Thread-6 : aaa
          *  Thread-7 : aaa
          *  Thread-8: aaa
          *  Thread-9 : aaa
          *
          * @param key
          * @return
          */
         // public Object getData(String key) {
         // Object value = cacheMap.get(key);
         // if (value == null) {
         // System.out.println("从数据库查询数据！");
         // cacheMap.put(key, "aaa");
         // }
         // return value;
         // }

         /**
          * 2.0 使用synchronized 同步 代码块 解决并发问题 实现方式简单 直接加synchronized 关键字
          *
          * 从数据库查询数据！
          *  Thread-4 : bbb
          *  Thread-1 : bbb
          *  Thread-2 : bbb
          *  Thread-0 : bbb
          *  Thread-3 : bbb
          *  Thread-8 : bbb
          *  Thread-7 : bbb
          *  Thread-6 : bbb
          *  Thread-9 : bbb
          *  Thread-5 : bbb
          *
          * @param key
          * @return
          */
 //         public synchronized Object getData(String key){
 //
 //         if ( cacheMap.get(key)==null) {
 //         System.out.println("从数据库查询数据！");
 //         cacheMap.put(key, "bbb");
 //         }
 //         return cacheMap.get(key);
 //         }

         /**
          * 3.0 使用读写锁
          *
                         从数据库查询数据！
             Thread-1 : ccc
             Thread-3 : ccc
             Thread-4 : ccc
             Thread-2 : ccc
             Thread-0 : ccc
             Thread-5 : ccc
             Thread-7 : ccc
             Thread-8 : ccc
             Thread-9 : ccc
             Thread-6 : ccc
          */
         private  ReadWriteLock rwl = new ReentrantReadWriteLock();
         public Object getData(String key) {
             //加锁了就要try finally ,避免异常情况下 代码一直被锁
             rwl.readLock().lock();
             try {
                 if (cacheMap.get(key) == null) {
                     try{
                         //读锁 解掉 是为了写锁 加锁
                         rwl.readLock().unlock();
                         //加锁了就要try finally ,避免异常情况下 代码一直被锁
                         rwl.writeLock().lock();
                         // 避免第一个线程写完数据，后面的线程接着写
                         if (cacheMap.get(key) == null) {
                             System.out.println("从数据库查询数据！");
                             cacheMap.put(key, "ccc");
                         }
                     }
                     finally{
                         rwl.writeLock().unlock();
                     }
                     rwl.readLock().lock();
                 }
             } finally {
                 rwl.readLock().unlock();
             }

             return cacheMap.get(key);
         }
     }
 }