基于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);
        }
    }
}