第一节使用ReentrantLock类
使用下面代码获取ReenTrantLock对象lock
private Lock lock = new ReentrantLock();
调用lock.lock()方法可以对代码进行加锁，调用lock.unlock()方法对代码进行解锁。
注：需要进行加锁的代码放在lock()与unlock()方法中。
调用了lock()方法代码的线程会持有“对象监视器”，其他线程只有等待锁被释放时再次争抢，效果跟使用synchronized关键字一样，线程间还是顺序执行的。
类ReentrantLock实现等待/同步功能，需要借助于condition对象。
Condition类具有很好的灵活性，可以实现多路通知功能：在一个Lock对象中创建多个Condition（对象监视器）实例，线程对象可以注册在指定的Condition中，从而有选择性地进行线程通知，在调度线程上更灵活。
在使用notify()/notifyAll()方法进行通知时，被通知的线程是由JVM随机选择的，但使用ReentrantLock结合Condition类是可以实现前面介绍过的“选择性通知”，这个功能是常用，且在Condition中是默认的。
通过下面代码获取Condition实例
private Lock lock = new ReentrantLock();private Condition condition = lock.newCondition();
然后使用condition.await()来进行等待操作。
注：在进行await()前，必须调用lock.lock()来获取监视器对象，否则的话就会爆出异常：java.lang.IllegalMonitorStateException（无监视器异常）。
Object类中的wait()方法相当于Condition类中的await()方法。
Object类中的wait(long timeout)方法相当于Condition类中的await(long time, TimeUnit unit)方法。
Object类中的notify()方法相当于Condition类中的single()方法。
Object类中的notifyAll()方法相当于Condition类中的singleAll()方法。
一个Condition对象可以通过singleAll()方法唤醒所有调用lock.newCondition().await()的线程。
但是若想实现只唤醒部分线程，只能使用多个Condition对象了，这也就是Condition对象可以唤醒部分指定线程，提高程序运行效率。
若想实现Condition对象唤醒部分指定线程。一定要是调用等待的Condition对象与调用唤醒的Condition保持是一个Condition对象。
public class Service { private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); private boolean flag = false; public void set() { try { lock.lock(); while (flag == true) { condition.await(); } System.out.println("我是set"); flag = true; condition.signal(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } public void get() { try { lock.lock(); while (flag == false) { condition.await(); } System.out.println("我是get"); flag = false; condition.signal(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } }} 一个线程调用set()，一个线程调用get()就可以实现一对一交替打印。
service代码还是同1.7，执行时开启多条线程即可，但是会遇到“假死”问题，可以通过将signal()改为signalAll()来解决。
锁Lock分为“公平锁”与“非公平锁”。
公平锁：标识线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。
非公平锁：一种线程抢占机制，是随机获取锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方法可能会导致某些线程一直拿不到锁，自然不公平。
创建的方式就是：
private Lock lock = new ReentrantLock(Boolean flag);
flag为true就是公平锁，flag为false就是非公平锁。
1）int getHoldCount() 查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
2）int getQueueLength() 返回正等待获取此锁定线程估计数。
比如有5个线程，一个线程先执行await()方法，那么在调用getQueueLength()方法后返回值是4，说明有4个线程同时在等待lock的释放。
3）int getWaitQueueLength(Condition condition) 返回等待与此锁定相关的给定条件Condition的线程估计数。
比如有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength()返回的值就是5。
注：以上都是ReentrantLock类的API
1）boolean hasQueuedThread(Thread thread) 查询指定的线程是否正在等待获取此锁定。
2）boolean hasQueuedThreads() 查询是否有线程正在等待获取此锁定。
3）boolean hasWaiters(Condition condition) 查询是否有线程正在等待与此锁定有关的condition条件。
注：以上都是ReentrantLock类的API
1）boolean isFair() 判断是不是公平锁
2）boolean isHeldByCurrentThread() 查询当前线程是否保持此锁定
3）boolean isLocked() 查询此锁定是否由任意线程保持
注：以上都是ReentrantLock类的API
1）void lockInterruptibly() 如果当前线程未被中断（不处于中断状态），则获得锁定，如果已经被检测中断（处于中断状态）则出现异常。
爆出java.lang.InterruptedException异常。
2）boolean tryLcok() 仅在调用时锁定未被另一个线程保持的情况下，才获得该锁定。
3）boolean tryLock(long timeout, TimeUnit unit) 如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获得该锁定。
注：以上都是ReentrantLock类的API
此方法为condition的方法await()的替代。可以避免在挂起的时候遇到打断状态（interrupt）而爆出异常。
在指定时间后唤醒自己。参数为long
在线程等待期间也可以被其他线程唤醒。
此方法是condition的API
就是利用多个Condition实现顺序执行。
public class Main { volatile private static int flag = 1; private static ReentrantLock lock = new ReentrantLock(); final private static Condition c1 = lock.newCondition(); final private static Condition c2 = lock.newCondition(); final private static Condition c3 = lock.newCondition(); public static void main(String[] args) throws Exception{ Thread threadA = new Thread() { @Override public void run() { try { lock.lock(); while (flag != 1) { c1.await(); } for (int i = 0; i < 3; i++) { System.out.println("ThreadA" + (i + 1)); } flag = 2; c2.signalAll(); }catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } }; Thread threadB = new Thread() { @Override public void run() { try { lock.lock(); while (flag != 2) { c2.await(); } for (int i = 0; i < 3; i++) { System.out.println("ThreadB" + (i + 1)); } flag = 3; c3.signalAll(); }catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } }; Thread threadC = new Thread() { @Override public void run() { try { lock.lock(); while (flag != 3) { c3.await(); } for (int i = 0; i < 3; i++) { System.out.println("ThreadC" + (i + 1)); } flag = 1; c1.signalAll(); }catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } }; Thread[] a = new Thread[5]; Thread[] b = new Thread[5]; Thread[] c = new Thread[5]; for (int i = 0; i < 5; i++) { a[i] = new Thread(threadA); b[i] = new Thread(threadB); c[i] = new Thread(threadC); a[i].start(); b[i].start(); c[i].start(); } }} 第二节使用ReentrantReadWriteLock类
实际上ReentrantLock虽然能够保证实例变量的线程安全性，但是效率比较低。
为了在一些不需要操作实例变量的方法中，使用一些效率较高的锁来实现提升运行效率，即使用ReentrantReadWriteLock读写锁。
读写锁表示有两个锁，一个是读操作相关的锁，也成为共享锁；
另一个是写操作相关的锁，也叫排他锁。
也就是说读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程进行写操作时，多个进行读操作的线程都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进
行写入操作。
注：多个线程可以同时进行读操作，但同一时刻只允许一个Thread进行写入操作。
可以通过如下代码获取读写锁
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock()
就可以获得读锁，并进行加锁。
lock.readLock().unlock()
释放读锁。
注：读锁是共享锁。
lock.writeLock().lock()
就可以获得写锁，并进行加锁。
lock.writeLock().unlock()
释放写锁。
注：写锁是互斥锁。
读锁与写锁是互斥的，也就是说不管是读锁先加锁还是写锁先加锁，只要两者相遇都是互斥的，必须等待其中一个释放线程后才能够再获得锁。
“读写”、“写读”、“写写”都是互斥的（因为写锁时互斥锁，所以只要出现写锁，就一定是互斥的）
“读读”是共享的，非互斥的。
本章总结：
本章用Lock来替换掉了synchronized关键字。
Lock很重要，重要到什么程度？很多并发包的源码都是通过Lock实现的。学好了Lock，有助于你理解你进一步进阶去看一些并发的源码。