读写锁（ReadWriteLock）的使用

Definition

读写锁包含一对相关的锁，读锁用于只读操作，写锁用于写操作。读锁可能由多个读线程同时运行，写锁是唯一的。

Direction

1、读锁和写锁之间是互斥的，同一时间只能有一个在运行。但是可以有多个线程同时读取数据。

2、写入数据之前必须重新确认(ReCheck)状态，因为其他的线程可能会拿到写锁再一次修改我们已经修改过的值。这是因为前一个线程拿到写锁之后，后面的线程会被阻塞。当前一个线程释放写锁之后，被阻塞的线程会继续运行完成被阻塞的部分代码，所以才会出现这样的情况。

3、当某一个线程上了写锁之后，自己仍然可以上读锁，之后在释放写锁，这是一种降级(Downgrade)的处理方法。

Method

读写锁（ReadWriteLock）包含如下两个方法：

1.读锁

Lock readLock()

2.写锁

Lock writeLock()

Example

以下代码在开始读数据的时候上读锁，当有一个线程发现没有数据时，释放读锁，上写锁，开始写入数据。

数据写入完成后释放写锁，并还原成读锁，实现了简单的读和写之间的互斥。

示例代码：

    private ReadWriteLock rwl = new ReentrantReadWriteLock();//定义读写锁
    public Object getData(String key){
        //使用读写锁的基本结构
        rwl.readLock().lock();
        Object value = null;
        try{
            value = cache.get(key);
            if(value == null){
                rwl.readLock().unlock();
                rwl.writeLock().lock();
                try{
                    // Recheck state because another thread might have
                    // acquired write lock and changed state before we did.
                    if(value == null){
                        value = "aaaa";//写入数据
                    }
                }finally{
                    rwl.writeLock().unlock();
                }
                rwl.readLock().lock();
            }
        }finally{
            rwl.readLock().unlock();
        }
        return value;
    }

读写锁的完整使用示例：

public class Test {
    public static void main(String[] args) {
        final Queue q = new Queue();
        for(int i=0;i<3;i++)
        {
            new Thread(){
                public void run(){
                    while(true){
                        q.get();                        
                    }
                }
            }.start();

            new Thread(){
                public void run(){
                    while(true){
                        q.put(new Random().nextInt(10000));
                    }
                }        
            }.start();
        }
    }
}

class Queue{
    private Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
    ReadWriteLock rwl = new ReentrantReadWriteLock();
    public void get(){
        rwl.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!");
            Thread.sleep((long)(Math.random()*1000));
            System.out.println(Thread.currentThread().getName() + "have read data :" + data);            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            rwl.readLock().unlock();
        }
    }
    
    public void put(Object data){
        rwl.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!");                    
            Thread.sleep((long)(Math.random()*1000));
            this.data = data;        
            System.out.println(Thread.currentThread().getName() + " have write data: " + data);                    
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            rwl.writeLock().unlock();
        }
    }
}

部分输出结果如下：

Thread-0 be ready to read data!
Thread-2 be ready to read data!
Thread-4 be ready to read data!
Thread-4have read data :null
Thread-0have read data :null
Thread-2have read data :null
Thread-3 be ready to write data!
Thread-3 have write data: 9763
Thread-3 be ready to write data!
Thread-3 have write data: 5187
Thread-3 be ready to write data!
Thread-3 have write data: 2135
Thread-1 be ready to write data!
Thread-1 have write data: 180
Thread-1 be ready to write data!
Thread-1 have write data: 5979
Thread-1 be ready to write data!
Thread-1 have write data: 9495
Thread-1 be ready to write data!
Thread-1 have write data: 6363
Thread-1 be ready to write data!
Thread-1 have write data: 31
Thread-1 be ready to write data!
Thread-1 have write data: 7530
Thread-1 be ready to write data!
Thread-1 have write data: 1354
Thread-5 be ready to write data!
Thread-5 have write data: 3580
Thread-5 be ready to write data!
Thread-5 have write data: 5534
Thread-5 be ready to write data!
Thread-5 have write data: 2522
Thread-5 be ready to write data!
Thread-5 have write data: 2926
Thread-4 be ready to read data!
Thread-0 be ready to read data!
Thread-2 be ready to read data!
Thread-2have read data :2926
Thread-0have read data :2926
Thread-4have read data :2926