2.2 读写锁用于缓存数据
现在使用读写锁写一个模拟缓存数据的 demo，实现功能如下：现在有5个线程都需要拿数据，一开始是没有数据的，所以最先去拿数据的那个线程发现没数据，它就得去初始化一个数据，然后其他线程拿数据的时候就可以直接拿了。代码如下。
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(); //释放读锁 } }
从代码中可以看出，在 processCache 方法中对读锁和写锁的交替使用。一开始进来都是读数据的，所以一开始都是上了读锁，但是当第一个线程进来发现没有缓存数据的时候，它得写数据，那么此时它得先把读锁给释放掉，换了把写锁，告诉其他线程：“哥们，这里面根本没数据啊，我们被坑了，让我先弄个数据来吧，你们等会儿~”，等该线程初始化好了数据后，其他线程就可以读了，于是它又把读锁装起来了，把写锁释放了，然后它出去了。这就模拟了拿缓存数据的一个 demo，可以看出，在一个方法中，同一个线程可以操作两个锁的。看一下运行结果。
Thread-1: no cache!
Thread-1: already cached!
Thread-1 get data: 893
Thread-0 get data: 893
Thread-2 get data: 893
这和 Hibernate 中的那个 load(id, Class.class) 方法有点类似，先拿到的是代理对象，要使用该对象的时候，如果发现没有，就新产生一个，如果有了就直接拿来用。
2.3 读写锁用于缓存系统
继续进阶，如果现在要缓存多个数据，即要写一个缓存系统，那该如何做呢？一个缓存系统无非就是一个容器，可以存储很多缓存数据，很自然的想到使用一个 Map，专门装缓存数据，然后供多个线程去使用。所以整个涉及思路，跟上面缓存单个数据是一样的，不过就是多考了一些东西而已，看下代码。
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; //返回要取的数据 } }
整个代码的结构和上面的一样，理解了缓存单个数据后，这个代码也不难理解。这里只是个 demo，实际中可以是跟数据库打交道，第一次从缓存中拿肯定是没有的，那么就要去数据库中查，然后把取到的数据放到缓存中，下次别的线程来就能直接从缓存中取了。看一下运行结果。
Thread-0 write cache for cache1
Thread-0 has already written cache!
Thread-4 write cache for cache2
Thread-0: aaa1464782404722
Thread-4 has already written cache!
Thread-4: aaa1464782404723
Thread-3: aaa1464782404723
Thread-2: aaa1464782404722
Thread-1: aaa1464782404722
Thread-5: aaa1464782404723
从结果中可以看出，线程 0 首先去缓存中拿 key 为 cache1 的值，没拿到，往里面写了一个，然后线程 4 去缓存中拿 key 为 cache2 的值也没拿到，于是也写了一个，在此期间线程 0 把值拿了出来，后面几个线程也随后陆续的拿出来了。读写锁的应用还是很广泛的，而且很好用，就总结这么多吧。
