在如何解決原子性問題的最後，我們賣了個關子，互斥鎖不僅僅只有synchronized關鍵字，還可以用什麼來實現呢？ J.U.C包中還提供了一個叫做Locks的包，我好歹英語過了四級，聽名字我就能馬上大聲的說：Locks包必然也可以用作互斥！ ReentrantLock 我們可以通過從具體到抽象的方法 ...
在如何解決原子性問題的最後，我們賣了個關子，互斥鎖不僅僅只有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地址：
本文轉載自公眾號【胖滾豬學編程】 用漫畫讓編程so easy and interesting！歡迎關註！形象來源於微信表情包【胖滾家族】喜歡可以下載哦~
