01、背景介绍
我们介绍到了使用synchronized关键字可以实现线程同步安全的效果，以及采用wait()、notify()和notifyAll()方法，可以实现多个线程之间的通信协调，基本可以满足并发编程的需求。
但是采用synchronized进行加锁，这种锁一般都比较重，里面的实现机制也非常复杂，同时获取锁时必须一直等待，没有额外的尝试机制，如果编程不当，可能就容易发生死锁现象。
从 JDK 1.5 开始，引入了一个高级的处理并发的java.util.concurrent包，它提供了大量更高级的并发功能，能大大的简化多线程程序的编写。
比如我们今天要介绍的java.util.concurrent.locks包提供的ReentrantLock类，一个可重入的互斥锁，它具有与使用synchronized加锁一样的特性，并且功能更加强大。
下面我们一起来学习一下ReentrantLock类的基本玩法。
02、ReentrantLock 玩法介绍
在介绍ReentrantLock之前，我们先来看一下传统的使用synchronized对方法进行加锁的示例。
public class Counter {
private int count;
public void add() {
synchronized(this) {
count ++;
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
}
}
public int getCount() {
return count;
}
}public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
// 创建5个线程，同时对count进行加一操作
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
counter.add();
}
}).start();
}
// 假设休眠1秒，5个线程执行完毕
Thread.sleep(1000);
System.out.println("count：" + counter.getCount());
}输出结果如下：
ThreadName：Thread-0, count：1
ThreadName：Thread-1, count：2
ThreadName：Thread-2, count：3
ThreadName：Thread-3, count：4
ThreadName：Thread-4, count：5
count：5如果用ReentrantLock替代，只需要将Counter中的代码改造为如下：
public class Counter {
private final Lock lock = new ReentrantLock();
private int count;
public void add() {
// 加锁
lock.lock();
try {
count ++;
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
} finally {
// 释放锁
lock.unlock();
}
}
public int getCount() {
return count;
}
}运行程序，结果与上面一致，可以证明：ReentrantLock具备与synchronized一样的加锁功能。
同时，ReentrantLock还具备在指定的时间内尝试获取锁的机制，比如下面这行代码：
if (lock.tryLock(3, TimeUnit.SECONDS)) {
try {
...
} finally {
lock.unlock();
}
}尝试在 3 秒内获取锁，如果获取不到就返回false，程序不需要无限等待下去，这个功能在实际开发中使用非常的广泛。
从上面的示例代码，我们可以总结出synchronized和ReentrantLock有以下几点不一样。
- ReentrantLock需要手动调用加锁方法；而synchronized不需要，它采用了隐藏的加锁方式，借助 jvm 来实现
- synchronized不需要考虑异常；而ReentrantLock获取锁之后，要在finally中正确的释放锁，否则会影响其它线程
- ReentrantLock拥有尝试获取锁的超时机制，利用它可以避免无限等待；而synchronized不具备
- synchronized是 Java 语言层面提供的语法；而ReentrantLock是 Java 代码实现的可重入锁
因此，在并发编程中，使用ReentrantLock比直接使用synchronized更灵活、更安全，采用tryLock(long time, TimeUnit unit)方法，即使未获取到锁也不会导致死锁。
03、ReentrantLock 和 synchronized 持有的对象监视器是同一个吗？
可能有的同学会发出这样的一个问题，使用ReentrantLock进行加锁和使用synchronized加锁，两者持有的对象监视器是同一个吗？
下面我们一起来看一个例子。
public class Counter {
private final Lock lock = new ReentrantLock();
private int count;
public synchronized void methodA() {
System.out.println("ThreadName：" + Thread.currentThread().getName() + "，begin methodA, count：" + getCount());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count ++;
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
}
public void methodB() {
// 加锁
lock.lock();
try {
System.out.println("ThreadName：" + Thread.currentThread().getName() + "，begin methodB, count：" + getCount());
Thread.sleep(3000);
count ++;
System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
} catch (Exception e){
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
}
}
public int getCount() {
return count;
}
}public class MyThreadA extends Thread {
private Counter counter;
public MyThreadA(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
counter.methodA();
}
}public class MyThreadB extends Thread {
private Counter counter;
public MyThreadB(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
counter.methodB();
}
}public class MyThreadTest {
public static void main(String[] args) {
Counter counter = new Counter();
MyThreadA threadA = new MyThreadA(counter);
threadA.start();
MyThreadB threadB = new MyThreadB(counter);
threadB.start();
}
}看一下运行结果：
ThreadName：Thread-0，begin methodA, count：0
ThreadName：Thread-1，begin methodB, count：0
ThreadName：Thread-0, count：2
ThreadName：Thread-1, count：2从日志上可以看出，采用两个线程分别采用synchronized和ReentrantLock两种加锁方式对count进行操作，两个线程交替执行，可以得出一个结论：synchronized和ReentrantLock持有的对象监视器不同。
04、Condition 基本用法
在之前的文章中，我们介绍了在synchronized同步方法／代码块中，使用wait()、notify()和notifyAll()可以实现线程之间的等待／通知模型。
ReentrantLock同样也可以，只需要借助Condition类即可实现，Condition提供的await()、signal()、signalAll()原理和synchronized锁对象的wait()、notify()、notifyAll()是一致的，并且其行为也是一样的。
我们还是先来看一个简单的示例。
public class Counter {
private final Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private int count;
public void await(){
// 加锁
lock.lock();
try {
condition.await();
System.out.println("await等待结束，count：" + getCount());
} catch (Exception e){
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
}
}
public void signal(){
// 加锁
lock.lock();
try {
count++;
// 唤醒某个等待线程
condition.signal();
// 唤醒所有等待线程
// condition.signalAll();
System.out.println("signal 唤醒通知完毕");
} catch (Exception e){
e.printStackTrace();
} finally {
// 释放锁
lock.unlock();
}
}
public int getCount() {
return count;
}
}public class MyThreadA extends Thread {
private Counter counter;
public MyThreadA(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
counter.await();
}
}public class MyThreadB extends Thread {
private Counter counter;
public MyThreadB(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
counter.signal();
}
}public class MyThreadTest {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
// 先启动执行等待的线程
MyThreadA threadA = new MyThreadA(counter);
threadA.start();
Thread.sleep(3000);
// 过3秒，再启动执行通知的线程
MyThreadB threadB = new MyThreadB(counter);
threadB.start();
}
}看一下运行结果：
signal 通知完毕
await等待结束，count：1从结果上看很明显的看出，等待线程MyThreadA先启动，过了 3 秒之后再启动了MyThreadB，但是signal()方法先执行完毕，再通知await()方法执行,符合代码预期。
这个例子也证明了一点：condition.await()方法是释放了锁，不然signal()方法体不会被执行。
相比wait/notify/notifyAll的等待／通知模型，Condition更加灵活，理由有以下几点：
- notify()方法唤醒线程时，被通知的线程由 Java 虚拟机随机选择；而采用ReentrantLock结合Condition可以实现有选择性地通知，这一特性在实际编程中非常实用
- 一个Lock里面可以创建多个Condition实例，实现多路通知，使用多个Condition的应用场景很常见，比如ArrayBlockingQueue
05、参考
1、https://www.cnblogs.com/xrq730/p/4855155.html
2、https://www.liaoxuefeng.com/wiki/
