【并发技术12】线程锁技术的使用（二）

public class ReadWriteLockTest2 {
   public static void main(String[] args) {
       CacheData cache = new CacheData();
       for(int i = 1; i <= 5; i ++) { //开启5个线程
           new Thread(new Runnable() {
               @Override
               public void run() {
                   cache.processCache(); //都去拿数据
               }
           }).start();
       }
   }
}
class CacheData {
   private Object data = null; // 需要缓存的数据
   private boolean cacheValid; //用来标记是否有缓存数据
   private ReadWriteLock rwl = new ReentrantReadWriteLock();// 定义读写锁
   public void processCache() {
       rwl.readLock().lock(); //上读锁
       if(!cacheValid) { //如果没有缓存，那说明是第一次访问，需要给data赋个值
           rwl.readLock().unlock(); //先把读锁释放掉
           rwl.writeLock().lock(); //上写锁
           if(!cacheValid) {
               System.out.println(Thread.currentThread().getName() + ": no cache!");
               data = new Random().nextInt(1000); //赋值
               cacheValid = true; //标记已经有缓存了
               System.out.println(Thread.currentThread().getName() + ": already cached!");
           }
           rwl.readLock().lock(); //再把读锁上上
           rwl.writeLock().unlock(); //把刚刚上的写锁释放掉
       }
       System.out.println(Thread.currentThread().getName() + " get data: " + data);
       rwl.readLock().unlock(); //释放读锁
   }
}

public class CacheDemo {
   public static void main(String[] args) {
       Cache cac = new Cache();
       for(int i = 0; i < 3; i ++) { //开启三个线程去缓存中拿key为cache1的数据，
           new Thread(new Runnable() {
               @Override
               public void run() {
                   String value = (String) cac.getData("cache1"); //第一个进入的线程要先写一个数据进去（相当于第一次从数据库中取）    
                   System.out.println(Thread.currentThread().getName() + ": " + value);    
               }
           }).start();
       }
       for(int i = 0; i < 3; i ++) { //开启三个线程去缓存中拿key为cacahe2的数据
           new Thread(new Runnable() {
               @Override
               public void run() {
                   String value = (String) cac.getData("cache2");//第一个进入的线程要先写一个数据进去（相当于第一次从数据库中取）
                   System.out.println(Thread.currentThread().getName() + ": " + value);
               }
           }).start();
       }
   }
}
class Cache {
   //存储缓存数据的Map，注意HashMap是非线程安全的，也要进行同步操作
   private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>());
   private ReadWriteLock rwl = new ReentrantReadWriteLock(); //定义读写锁
   public synchronized Object getData(String key) {
       rwl.readLock().lock(); //上读锁
       Object value = null;
       try {
           value = cache.get(key); //根据key从缓存中拿数据
           if (value == null) { //如果第一次那该key对应的数据，拿不到
               rwl.readLock().unlock(); //释放读锁
               rwl.writeLock().lock(); //换成写锁
               try {
                   if (value == null) { //之所以再去判断，是为了防止几个线程同时进入了上面那个if，然后一个个都来重写赋值一遍
                       System.out.println(Thread.currentThread().getName() + " write cache for " + key);
                       value = "aaa" + System.currentTimeMillis(); // 实际中是去数据库中取，这里只是模拟
                       cache.put(key, value); //放到缓存中
                       System.out.println(Thread.currentThread().getName() + " has already written cache!");
                   }
               } finally {
                   rwl.writeLock().unlock(); //写完了释放写锁
               }
               rwl.readLock().lock(); //换读锁
           }
       } finally {
           rwl.readLock().unlock(); //最后呢释放读锁
       }
       return value; //返回要取的数据
   }
}