在如何解決原子性問題的最後，我們賣了個關子，互斥鎖不僅僅只有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！歡迎關注！形象來源於微信表情包【胖滾家族】喜歡可以