在如何解决原子性问题的最后，我们卖了个关子，互斥锁不仅仅只有synchronized关键字，还可以用什么来实现呢？
J.U.C包中还提供了一个叫做Locks的包，我好歹英语过了四级，听名字我就能马上大声的说：Locks包必然也可以用作互斥！
ReentrantLock
我们可以通过从具体到抽象的方法来揭开Locks包的神秘面试。
从图中可以看出，有个叫做ReentrantLock实现了Lock接口，那么就从它入手吧！
顾名思义，ReentrantLock叫做可重入锁，所谓可重入锁，顾名思义，指的是线程可以重复获取同一把锁。
ReentrantLock也是互斥锁，因此也可以保证原子性。
先写一个简单的demo上手吧，就拿原子性问题中两个线程分别做累加的demo为例，现在使用ReentrantLock来改写：
private void add10K() {
// 获取锁
reentrantLock.lock();
try {
int idx = 0;
while (idx++ < 10000) {
count++;
}
} finally {
// 保证锁能释放
reentrantLock.unlock();
}
}
ReentrantLock在这里可以达到和synchronized一样的效果，为了方便你回忆，我再次把synchronized实现互斥的代码贴上来：
private synchronized void add10K(){
int start = 0;
while (start ++ < 10000){
this.count ++;
}
}
由于它俩都算互斥锁，所以大家都喜欢拿它们做比较，我们来看看究竟有什么区别吧
ReentrantLock与synchronized的区别
1、重入
synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重入，但加锁和解锁需要手动进行，且次数需一样，否则其他线程无法获得锁。
2、实现
synchronized是JVM实现的、而ReentrantLock是JDK实现的。说白了就是，是操作系统来实现，还是用户自己敲代码实现。
3、性能
在 Java 的 1.5 版本中，synchronized 性能不如 SDK 里面的 Lock，但 1.6 版本之后，synchronized 做了很多优化，将性能追了上来。
4、功能
ReentrantLock锁的细粒度和灵活度，都明显优于synchronized ，毕竟越麻烦使用的东西肯定功能越多啦！
特有功能一：可指定是公平锁还是非公平锁，而synchronized只能是非公平锁。
公平的意思是先等待的线程先获取锁。可以在构造函数中指定公平策略。
// 分别测试为true 和 为false的输出。为true则输出顺序一定是A B C 但是为false的话有可能输出A C B
private static final ReentrantLock reentrantLock = new ReentrantLock(true);
public static void main(String[] args) throws InterruptedException {
ReentrantLockDemo2 demo2 = new ReentrantLockDemo2();
Thread a = new Thread(() -> { test(); }, "A");
Thread b = new Thread(() -> { test(); }, "B");
Thread c = new Thread(() -> { test(); }, "C");
a.start();b.start();c.start();
}
public static void test() {
reentrantLock.lock();
try {
System.out.println("线程" + Thread.currentThread().getName());
} finally {
reentrantLock.unlock();//一定要释放锁
}
}
在原子性文章的最后，我们还卖了个关子，以转账为例，说明synchronized会导致死锁的问题，即两个线程你等我的锁，我等你的锁，两方都阻塞，不会释放！为了方便，我再次把代码贴上来：
static void transfer(Account source,Account target, int amt) throws InterruptedException {
// 锁定转出账户 Thread1锁定了A Thread2锁定了B
synchronized (source) {
Thread.sleep(1000);
log.info("持有锁{} 等待锁{}",source,target);
// 锁定转入账户 Thread1需要获取到B,可是被Thread2锁定了。Thread2需要获取到A，可是被Thread1锁定了。所以互相等待、死锁
synchronized (target) {
if (source.getBalance() > amt) {
source.setBalance(source.getBalance() - amt);
target.setBalance(target.getBalance() + amt);
}
}
}
}
而ReentrantLock可以完美避免死锁问题，因为它可以破坏死锁四大必要条件之一的：不可抢占条件。这得益于它这么几个功能：
特有功能二：非阻塞地获取锁。如果尝试获取锁失败，并不进入阻塞状态，而是直接返回false，这时候线程不用阻塞等待，可以先去做其他事情。所以不会造成死锁。
// 支持非阻塞获取锁的 API
boolean tryLock();
现在我们用ReentrantLock来改造一下死锁代码
static void transfer(Account source, Account target, int amt) throws InterruptedException {
Boolean isContinue = true;
while (isContinue) {
if (source.getLock().tryLock()) {
log.info("{}已获取锁 time{}", source.getLock(),System.currentTimeMillis());
try {
if (target.getLock().tryLock()) {
log.info("{}已获取锁 time{}", target.getLock(),System.currentTimeMillis());
try {
log.info("开始转账操作");
source.setBalance(source.getBalance() - amt);
target.setBalance(target.getBalance() + amt);
log.info("结束转账操作 source{} target{}", source.getBalance(), target.getBalance());
isContinue=false;
} finally {
log.info("{}释放锁 time{}", target.getLock(),System.currentTimeMillis());
target.getLock().unlock();
}
}
} finally {
log.info("{}释放锁 time{}", source.getLock(),System.currentTimeMillis());
source.getLock().unlock();
}
}
}
}
tryLock还支持超时。调用tryLock时没有获取到锁，会等待一段时间，如果线程在一段时间之内还是没有获取到锁，不是进入阻塞状态，而是throws InterruptedException，那这个线程也有机会释放曾经持有的锁，这样也能破坏死锁不可抢占条件。boolean tryLock(long time, TimeUnit unit)
特有功能三：提供能够中断等待锁的线程的机制
synchronized 的问题是，持有锁 A 后，如果尝试获取锁 B 失败，那么线程就进入阻塞状态，一旦发生死锁，就没有任何机会来唤醒阻塞的线程。
但如果阻塞状态的线程能够响应中断信号，也就是说当我们给阻塞的线程发送中断信号的时候，能够唤醒它，那它就有机会释放曾经持有的锁 A。这样就破坏了不可抢占条件了。ReentrantLock可以用lockInterruptibly方法来实现。
public static void main(String[] args) throws InterruptedException {
ReentrantLockDemo5 demo2 = new ReentrantLockDemo5();
Thread th1 = new Thread(() -> {
try {
deadLock(reentrantLock1, reentrantLock2);
} catch (InterruptedException e) {
System.out.println("线程A被中断");
}
}, "A");
Thread th2 = new Thread(() -> {
try {
deadLock(reentrantLock2, reentrantLock1);
} catch (InterruptedException e) {
System.out.println("线程B被中断");
}
}, "B");
th1.start();
th2.start();
th1.interrupt();
}
public static void deadLock(Lock lock1, Lock lock2) throws InterruptedException {
lock1.lockInterruptibly(); //如果改成用lock那么是会一直死锁的
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock2.lockInterruptibly();
try {
System.out.println("执行完成");
} finally {
lock1.unlock();
lock2.unlock();
}
}
特有功能四、可以用J.U.C包中的Condition实现分组唤醒需要等待的线程。而synchronized只能notify或者notifyAll。这里涉及到线程之间的协作，在后续章节会详细讲解，敬请关注公众号【胖滚猪学编程】。
文中代码github地址：