重入锁 ReentrantReadWriteLock

1.lock方法-获取锁，默认情况是不公平的锁，如果其它线程占用锁的话，会等待，当线程较少的时候性能不及synchronized,
当线程较多的时候，性能较为优秀，其底层用了AQS实现。
2.unlock方法是释放锁，必须要在代码finally里面，避免没有释放锁导致线程溢出问题。
3.tryLock方法是尝试获取锁，如果锁被其他线程占有，那么获取失败，则跳过执行。其应用场景多用于进行非重要任务防止重复执行。
4.lockInterruptibly方法主要用于可以被其它线程调用thread.interrupt()线程中断，然后抛出异常。
synchronized与Lock在默认情况下是不会响应中断(interrupt)操作，会继续执行完。lockInterruptibly()提供了可中断锁来解决此问题
5.ReentrantLock(true)构造一个公平的锁，谁等了最久给谁用，但是会消耗更多的时间来排队，线程多的情况其性能会比synchronized差，
公平情况下，操作会排一个队按顺序执行，来保证执行顺序。
不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）
6.Condition
我们要打印1到9这9个数字，由A线程先打印1，2，3，然后由B线程打印4,5,6，然后再由A线程打印7，8，9. 这道题有很多种解法，
现在我们使用Condition来做这道题（使用Object的wait，notify方法的解法在这里）。

import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Test{    static class NumberWrapper {        public int value = 1;    }    public static void main(String[] args) {        //初始化可重入锁        final Lock lock = new ReentrantLock();        //第一个条件当屏幕上输出到3        final Condition reachThreeCondition = lock.newCondition();        //第二个条件当屏幕上输出到6        final Condition reachSixCondition = lock.newCondition();        //NumberWrapper只是为了封装一个数字，一边可以将数字对象共享，并可以设置为final        //注意这里不要用Integer, Integer 是不可变对象        final NumberWrapper num = new NumberWrapper();        //初始化A线程        Thread threadA = new Thread(new Runnable() {            @Override            public void run() {                //需要先获得锁                lock.lock();                try {                    System.out.println("threadA start write");                    //A线程先输出前3个数                    while (num.value <= 3) {                        System.out.println(num.value);                        num.value++;                    }                    //输出到3时要signal，告诉B线程可以开始了                    reachThreeCondition.signal();                } finally {                    lock.unlock();                }                lock.lock();                try {                    //等待输出6的条件                    reachSixCondition.await();                    System.out.println("threadA start write");                    //输出剩余数字                    while (num.value <= 9) {                        System.out.println(num.value);                        num.value++;                    }                } catch (InterruptedException e) {                    e.printStackTrace();                } finally {                    lock.unlock();                }            }        });        Thread threadB = new Thread(new Runnable() {            @Override            public void run() {                try {                    lock.lock();                    while (num.value <= 3) {                        //等待3输出完毕的信号                        reachThreeCondition.await();                    }                } catch (InterruptedException e) {                    e.printStackTrace();                } finally {                    lock.unlock();                }                try {                    lock.lock();                    //已经收到信号，开始输出4，5，6                    System.out.println("threadB start write");                    while (num.value <= 6) {                        System.out.println(num.value);                        num.value++;                    }                    //4，5，6输出完毕，告诉A线程6输出完了                    reachSixCondition.signal();                } finally {                    lock.unlock();                }            }        });        //启动两个线程        threadB.start();        threadA.start();    }}