Lock应用之 读写锁

不管是内部锁还是Lock都是独占锁，或者称之排他锁，即读写互斥、写写互斥、读读互斥；与排他锁相对的另一种锁是共享锁，Java的ReadWriteLock是一种共享锁，提供读读共享，但读写和写写仍然互斥。

ReadWriteLock最大的特性就是读读共享，比如A线程读锁正在进行读取操作，此时如果B线程请求读锁，那么B线程可以马上顺利获得读锁而无需等待，但此时如果C线程请求写锁，那么C线程需要等待锁可用。ReadWriteLock由于提供了读读共享而增加了复杂性，所以在读写都相当频繁的场景并不能体现出性能优势，只有在读操作极多而写操作极少的场景下才能体现其性能优势。比如，一个应用系统安装完成后需要导入一批维护性的初始化数据，这些数据可以通过界面修改，但需要修改的情况极少，当系统一启动就会自动加载初始化数据到指定数据结构（如HashMap）供各个模块读取使用，那么可以为这些数据的读写加ReadWriteLock，以提高读取性能并保持数据的一致性。

ReentrantReadWriteLock类是ReadWriteLock接口的一个实现，它与ReentrantLock类一样提供了公平竞争与不公平竞争两种机制，默认也是使用非公平竞争机制。ReentrantLock是排他锁，使用非公平竞争机制时，抢占的机会相对还是比较少的，只有当新请求恰逢锁释放时才有机会抢占，所以发生线程饥饿的现象几乎很少。然而ReentrantReadWriteLock是共享锁，或者说读读共享，并且经常使用于读多写少的场景，即请求读操作的线程多而频繁而请求写操作的线程极少且间隔长，在这种场景下，使用非公平竞争机制极有可能造成写线程饥饿。比如，R1线程此时持有读锁且在进行读取操作，W1线程请求写锁所以需要排队等候，在R1释放锁之前，如果R2,R3,...,Rn 不断的到来请求读锁，因为读读共享，所以他们不用等待马上可以获得锁，如此下去W1永远无法获得写锁，一直处于饥饿状态。所以使用ReentrantReadWriteLock类时，小心选择公平机制，以免遇到出乎预料的结果。

最后，Java5的读写锁实现有瑕疵，可能发生死锁，在Java6已经修复，所以避免使用Java5读写锁。

示例代码：

import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class TestReadWriteLock {
    private static final int MAX_INDEX = 100;
    private HashMap<Integer,Integer> mInitDataMap;
    private ReadWriteLock mRWlock;
    private volatile boolean isNonStop;
                                
    public void start() {
        this.isNonStop = true;
    }
    public void stop() {
        this.isNonStop = false;
    }
    public TestReadWriteLock(){
        init();
    }
    private void init() {
        mInitDataMap = new HashMap<Integer,Integer>(MAX_INDEX);
        mRWlock = new ReentrantReadWriteLock();
                                    
        for(int i=0; i<MAX_INDEX; i++){
            mInitDataMap.put(i, i);
        }
    }
    private class Reader implements Runnable{
        @Override
        public void run() {
            while(isNonStop){
                mRWlock.readLock().lock();
                System.out.println(Thread.currentThread().getName() + ": get the read lock.");
                                            
                try{
                    mInitDataMap.get((int)((MAX_INDEX-1)*Math.random()));
                                                
                    //此处增加读取时间使写线程更容易处于饥饿状态
                    /*try {
                        TimeUnit.MILLISECONDS.sleep((long) (1000*Math.random()));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                }
                finally{
                    mRWlock.readLock().unlock();
                }
            }          
        }
                                    
    }
                                
    private class Writer implements Runnable{
        @Override
        public void run() {
            while(isNonStop){
                mRWlock.writeLock().lock();
                System.out.println(Thread.currentThread().getName() + ": get the write lock.");
                                            
                try{
                    mInitDataMap.put((int)((MAX_INDEX-1)*Math.random()), (int)((MAX_INDEX-1)*Math.random()));
                                                
                    //此处增加读取时间使写线程更容易处于饥饿状态
                    /*try {
                        TimeUnit.MILLISECONDS.sleep((long) (1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                }
                finally{
                    mRWlock.writeLock().unlock();
                }
            }          
        }
                                    
    }
    public static void main(String[] args) throws InterruptedException {
        TestReadWriteLock testReadWriteLock = new TestReadWriteLock();
        testReadWriteLock.start();
                                    
        for(int i=0; i<5*MAX_INDEX; i++){
            new Thread(testReadWriteLock.new Reader()).start();
        }
                                    
        new Thread(testReadWriteLock.new Writer()).start();
                                    
        TimeUnit.SECONDS.sleep(5);
        testReadWriteLock.stop();
    }
}