ReentrantReadWriteLock可重入，锁升级，锁降级

public class ReentrantReadWriteLockTest {

    public static void main(String[] args) throws InterruptedException {
        // testReenter();
        // testUpgrade();
         testDowngrade();
    }

    /**
     * 在同一个线程中，在没有释放写锁的情况下，就去申请读锁，这属于锁降级，ReentrantReadWriteLock是支持的，不过锁的释放有问题，获取到锁就要释放锁
     * 为什么有锁的降级，当前线程进行写操作后， 当前线程后面可能还有读的操作，把写锁降级为读锁后，其他的线程可以进行读，但是不能写，提高了效率。
     */
    public static void testDowngrade() {
        ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();
        rtLock.writeLock().lock();
        System.out.println("writeLock");
        rtLock.readLock().lock();
        System.out.println("get read lock");
    }

    // 在同一个线程中，在没有释放读锁的情况下，就去申请写锁，这属于锁升级，ReentrantReadWriteLock是不支持的。
    public static void testUpgrade() {
        ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();
        rtLock.readLock().lock();
        System.out.println("get readLock.");
        // rtLock.readLock().unlock();
        rtLock.writeLock().lock();
        System.out.println("blocking");
        rtLock.writeLock().unlock();
    }

    //可重入锁，就是说一个线程在获取某个锁后，还可以继续获取该锁，即允许一个线程多次获取同一个锁,要注意的是获取多少次锁就要释放多少次锁，不然会发生死锁，例子讲的是两次获取写锁
    public static void testReenter() throws InterruptedException {
        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.writeLock().lock();
                System.out.println("Thread real execute");
                lock.writeLock().unlock();
            }
        });

        lock.writeLock().lock();
        lock.writeLock().lock();
        t.start();
        Thread.sleep();
        System.out.println("realse one once");
        lock.writeLock().unlock();
        // lock.writeLock().unlock();
    }

}