java多线程基础（四）ReadWriteLock读写锁

ReadWriteLock
ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();
 
    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();
}

ReentrantReadWriteLock

ReetrantReadWriteLock实现了ReadWriteLock接口并添加了可重入的特性，ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

为什么要有读锁写锁
读锁与读锁不互斥，读锁与写锁互斥，写锁与写锁互斥。这就是为什么要有读锁和写锁

锁降级：从写锁变成读锁；锁升级：从读锁变成写锁 ReentrantReadWriteLock不支持锁升级，支持锁降级。同一个线程中，在没有释放读锁的情况下，就去申请写锁属于锁升级，相反则是锁降级。

读锁

public class readThread extends Thread {
    private ReentrantReadWriteLock rw = null;

    public readThread(ReentrantReadWriteLock rw){
        this.rw = rw;
    }
    public void run(){
        rw.readLock().lock();
        for (int i=0;i<5;i++){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在进行读操作");
        }
        rw.readLock().unlock();
    }
}

public class test {
    public static void main(String args[]){
        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
        readThread t1 = new readThread(rw);
        readThread t2 = new readThread(rw);
        t1.start();
        t2.start();
    }
}

两个线程的读操作是同时执行的，即读锁与读锁不互斥。

写锁

public class writeThread extends Thread {
    private ReentrantReadWriteLock rw = null;
    public writeThread(ReentrantReadWriteLock rw){
        this.rw = rw;
    }

    public void run(){
        rw.writeLock().lock();
        for (int i=0;i<5;i++){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在进行写操作");
        }
        rw.writeLock().unlock();
    }
}

public class test {
    public static void main(String args[]){
        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
        writeThread t1 = new writeThread(rw);
        writeThread t2 = new writeThread(rw);
        t1.start();
        t2.start();
    }
}

从运行结果可以看出，两个线程的读操作是顺序执行的，写锁与写锁互斥。

读写线程一起执行

public class test {
    public static void main(String args[]){
        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
        writeThread t1 = new writeThread(rw);
        readThread t2 = new readThread(rw);
        t1.start();
        t2.start();
    }
}

读锁与写锁互斥