class CachedData {Object data;volatile boolean cacheValid;ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();void processCachedData() {rwl.readLock().lock();if (!cacheValid) {// Must release read lock before acquiring write lockrwl.readLock().unlock();rwl.writeLock().lock();// Recheck state because another thread might have acquired//   write lock and changed state before we did.if (!cacheValid) {data = ...cacheValid = true;}// Downgrade by acquiring read lock before releasing write lockrwl.readLock().lock();rwl.writeLock().unlock(); // Unlock write, still hold read}use(data);rwl.readLock().unlock();}}

package test;import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;/*** 设计一个缓存系统* 读写锁的应用。* JDK1.5自带的读写锁特性，读与读不互斥，读与写互斥，写与写互斥。* 为什么要使用读写锁？一句话概括那就是提高系统性能，如何提高呢？* 试想，对于所有对读的操作是不需要线程互斥的，而如果方法内* 使用了synchronized关键字同步以达到线程安全，对于所有的线程不管是读还是写的操作都要同步。* 这时如果有大量的读操作时就会又性能瓶颈。* * 所以，当一个方法内有多个线程访问，并且方法内有读和写读操作时，* 提升性能最好的线程安全办法时采用读写锁的机制对读写互斥、写写互斥。这样对于读读就没有性能问题了* @author zhurudong**/
public class CacheTest {// 缓存的mapprivate Map<String, Object> map = new HashMap<String, Object>();// 读写锁对象private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();/*** 从缓存中获取数据的方法* @param key* @return*/public Object getData(String key) {readWriteLock.readLock().lock();//读锁，只对写的线程互斥Object value = null;try {// 尝试从缓存中获取数据value = map.get(key);if (value == null) {readWriteLock.readLock().unlock();//发现目标值为null,释放掉读锁readWriteLock.writeLock().lock();//发现目标值为null,需要取值操作,上写锁try {value = map.get(key);// 很严谨这一步。再次取目标值if (value == null) {//很严谨这一步。再次判断目标值,防止写锁释放后，后面获得写锁的线程再次进行取值操作// 模拟DB操作value = new Random().nextInt(10000) + "test";map.put(key, value);System.out.println("db completed!");}readWriteLock.readLock().lock();//再次对读进行锁住，以防止写的操作，造成数据错乱} finally {/** 先加读锁再释放写锁读作用：* 防止在43行出多个线程获得写锁进行写的操作，所以在写锁还没有释放前要上读锁*/readWriteLock.writeLock().unlock();}}} finally {readWriteLock.readLock().unlock();}return value;}/***  test main* @param args*/public static void main(String[] args) {final CacheTest cache = new CacheTest();final String key = "user";for (int i = 0; i < 1000; i++) {new Thread(){public void run() {System.out.println(cache.getData(key));};}.start();}}
}

public Object getData1(String key) {if(key == null) return null;Object data = null;synchronized (key.intern()) {data = dataMap.get(key);if(data == null) {data = "query object";dataMap.put(key, data);}}return data;
}

    //源码里实际上是把ReentrantReadWriteLock封装在一个ReadWriteLockSync类里的，我不喜欢拐弯抹角，直接简单的提取出来了final ReadWriteLock[] rwlocks = new ReentrantReadWriteLock[2048];//这里是自己为了简单，源码里并不是这么简陋的{for(int i = 0;i < rwlocks.length;i++) {rwlocks[i] = new ReentrantReadWriteLock();}}//这里是源码里的方法public static int selectLock(final Object key, int numberOfLocks) throws CacheException {/*** 这里用自己和自己小1的数字取了一个与运算，目的就是保证numberOfLocks是2的n次方,比如8和7与1000  & 0111= 0000如果结果不等于0必然不是2的n次方  */int number = numberOfLocks & (numberOfLocks - 1);if (number != 0) {throw new CacheException("Lock number must be a power of two: " + numberOfLocks);}if (key == null) {return 0;} else {/**这里也很有意思，一般我们做估计就是hash(key) % numberOfLocks来定位数组的索引，他这样玩其实在numberOfLocks是2的n次方的情况下，是与%操作等效，如下8 % 4 = 8 & 31000& 0011= 0000 = 011 % 8 = 11 & 71011& 0111= 0011= 3每次看到别人用位运算，只能感叹，这尼玛才叫装B啊！*/int hash = hash(key) & (numberOfLocks - 1);return hash;}}//这里是源码里的hash函数，表示看不懂，就知道传一个对象进去可以出来一个int类型的值public static int hash(Object object) {int h = object.hashCode();h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);}

    /**这里使用支持并发的map是为了保证容器本身没有并发问题，容器的存取操作是原子的，后面getData2的同步控制是为了防止业务数据同时读写出现脏读等情况，比如一个key在读，同时也在写，到底读到的是写前还是写后的数据呢？这里是属于业务上的并发控制，至于容器上的并发控制就是明明两个不同的key去写因为抢同一个位置导致数据不一致等问题，就像存包裹，有两个人非要去存在一个箱子里就会出现争抢了。并不是说使用了线程并发库就不需要进行并发控制了，毕竟线程并发库里的读写，也只能保证单独的读写是原子操作，假设多个组合起来就不能保证原子性了*/private Map<String,Object> dataMap = new ConcurrentHashMap<>();public Object getData2(String key) {int locknum = selectLock(key,2048);ReadWriteLock rwlock = rwlocks[locknum];rwlock.readLock().lock();try {Object data = dataMap.get(key);if (data == null) {rwlock.readLock().unlock();rwlock.writeLock().lock();if(data == null) {data = "query object";dataMap.put(key, data);}rwlock.readLock().lock();rwlock.writeLock().unlock();}return data;} finally {rwlock.readLock().unlock();}}