可重入锁是一种排他锁，同一时间只允许一个线程操作竞争资源。读写锁是针对读、写场景设计的，允许多个线程同时持有锁。读写锁维护了一个读锁和一个写锁。其机制如下：

• 没有其它线程占用写锁的情况下，同一时间可以有多个线程加读锁。
• 没有任意线程占用读锁的情况下， 同一时间只有一个线程可以加写锁。

简单总结就是要么读，要么写，允许多个线程同时读，只允许一个线程单独写。看看源码。

复制
public interface ReadWriteLock {
 
    Lock readLock();
    
    Lock writeLock();
}

原来这是一个接口，它本身并不是锁对象，只是维护了一个读锁(readLock)，一个写锁(writeLock)。其实现类是ReentrantReadWriteLock.

复制
public class Demo16 {
    public static void main(String[] args) {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        readWriteLock.readLock().lock();
        new Thread(readWriteLock.readLock()::lock).start();
    }
}

上面程序可以正常退出，因为两个线程可以同时获取读锁，并不会hang住。

复制
public class Demo16 {
    public static void main(String[] args) {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        readWriteLock.writeLock().lock();
        new Thread(readWriteLock.readLock()::lock).start();
    }
}

上面代码则不能正常退出，因为主线程使用了写锁，被创建的子线程不允许获取读锁。

ReentrantReadWriteLock不仅拥有读、写锁的功能，还保留了写锁的可重入锁、公平|非公平锁的机制。

复制
public class Demo17 {
    public static void main(String[] args) {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        readWriteLock.writeLock().lock();
        readWriteLock.writeLock().lock();
        new Thread(() -> {
            System.out.println("thread2 try to lock");
            readWriteLock.writeLock().lock();
            System.out.println("thread2 lock successfully");
        }).start();
        readWriteLock.writeLock().unlock();
        System.out.println("thread1 unlock one time");
        readWriteLock.writeLock().unlock();
        System.out.println("thread2 unlock twice");
    }
}

输出为。

复制
thread1 unlock one time
thread2 try to lock
thread2 unlock twice
thread2 lock successfully

注意读锁不具备上述机制，因为它根本不是排他锁。公平锁的简单演示如下。

复制
public class Demo18 {
    public static void main(String[] args) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
        Runnable action = () -> {
            System.out.println("thread" + Thread.currentThread().getName() + "try to lock");
            lock.writeLock().lock();
            System.out.println("thread" + Thread.currentThread().getName() + " lock successfully");
            lock.writeLock().unlock();
        };
 
        for (int i = 0; i < 10; i++) {
            new Thread(action).start();
        }
    }
}

输出如下。

复制
threadThread-0try to lock
threadThread-2try to lock
threadThread-1try to lock
threadThread-0 lock successfully
threadThread-2 lock successfully
threadThread-3try to lock
threadThread-1 lock successfully
threadThread-4try to lock
threadThread-3 lock successfully
threadThread-5try to lock
threadThread-6try to lock
threadThread-4 lock successfully
threadThread-5 lock successfully
threadThread-6 lock successfully
threadThread-8try to lock
threadThread-7try to lock
threadThread-8 lock successfully
threadThread-7 lock successfully
threadThread-9try to lock
threadThread-9 lock successfully

真的很简单。下面讲点有意思的：锁降级和锁升级。先回顾下我们对读写锁机制的描述：

• 没有其它线程占用写锁的情况下，同一时间可以有多个线程加读锁。

发现没有，我们用的是其它，而不是任意。说人话就是，如果线程A持有写锁，其它线程就不允许持有读锁，A线程却可以。

复制
public class Demo19 {
    public static void main(String[] args) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        lock.writeLock();
        lock.readLock();
        System.out.println("get read lock...");
    }
}

输出如下。

复制
get read lock...

不过上面的例子中写锁与读锁的顺序不能反。再看之前我的概念也是这么写的。

• 没有任意线程占用读锁的情况下， 同一时间只有一个线程可以加写锁。

为什么呢？其实是因为写锁可以降级为读锁。换句话说，我本来是写锁，看见是自己人来了(同一个线程想获取读锁)，我把自己降级读锁，允许你进来和我玩。但是如果是读锁，即使我看见自己人来了，我也没有办法升级成为写锁阿。毕竟降级简单升级难。

看下列代码。

复制
public class Demo20 {
    public static void main(String[] args) throws InterruptedException {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        readWriteLock.writeLock().lock();
        readWriteLock.readLock().lock();
 
        new Thread(() -> {
            System.out.println("thrad2 to get read lock");
            readWriteLock.readLock().lock();
            System.out.println("thrad2 get read lock succussfully");
        }).start();
 
        TimeUnit.SECONDS.sleep(1);
        System.out.println("thread1 unlock write lock");
        readWriteLock.writeLock().unlock();
    }
}

结果是。

复制
thrad2 to get read lock
thread1 unlock write lock
thrad2 get read lock succussfully

原来写锁的降级只是一瞬间，就是在持有写锁的情况下同一线程想获取读锁的那一瞬间。