在如何解決原子性問題的最后，我們賣了個關子，互斥鎖不僅僅只有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！歡迎關注！形象來源于微信表情包【胖滾家族】喜歡可以下載哦~
轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/8617.html
標籤：大數據