1. 嘗試獲取鎖的方法如tryAcquire，這些一般是交給子類來實現(xiàn)的
2. 當線程是被調(diào)用Thread#interrupt方法喚醒，如果要響應(yīng)中斷，會拋出InterruptedException

//處理異常退出的node 
private void cancelAcquire(Node node) { 
 if (node == null) 
  return; 
 
 // 設(shè)置該節(jié)點不再關(guān)聯(lián)任何線程 
 node.thread = null; 
 
 // 跳過CANCELLED節(jié)點，找到一個有效的前繼節(jié)點 
 Node pred = node.prev; 
 while (pred.waitStatus > 0) 
  node.prev = pred = pred.prev; 
 
 // 獲取過濾后的有效節(jié)點的后繼節(jié)點 
 Node predNext = pred.next; 
 
 // 設(shè)置狀態(tài)為取消 
 node.waitStatus = Node.CANCELLED; 
 
 // case 1 
 if (node == tail && compareAndSetTail(node, pred)) { 
  compareAndSetNext(pred, predNext, null); 
 } else { 
  // case 2 
  int ws; 
  if (pred != head && 
   ((ws = pred.waitStatus) == Node.SIGNAL || 
    (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) && 
   pred.thread != null) { 
   Node next = node.next; 
   if (next != null && next.waitStatus <= 0) 
    compareAndSetNext(pred, predNext, next); 
  } else { 
   // case3 
   unparkSuccessor(node); 
  } 
 
  node.next = node; // help GC 
 } 
} 

將node出隊有如下三種情況

當前節(jié)點是tail

當前節(jié)點不是head的后繼節(jié)點，也不是tail

當前節(jié)點是head的后繼節(jié)點

「當前節(jié)點是tail」

compareAndSetTail，將tail指向pred compareAndSetNext，將pred的next指向null，也就是把當前節(jié)點移出隊列

在這里插入圖片描述

「當前節(jié)點不是head的后繼節(jié)點，也不是tail」

這里將node的前繼節(jié)點的next指向了node的后繼節(jié)點，即compareAndSetNext(pred, predNext, next)，「注意pred和node節(jié)點中間有可能有CANCELLED的節(jié)點，怕亂就沒畫出來」

「當前節(jié)點是head的后繼節(jié)點」

沒有對隊列進行操作，只是進行head后繼節(jié)點的喚醒操作(unparkSuccessor方法，后面會分析這個方法)，因為此時他是head的后繼節(jié)點，還是有可能獲取到鎖的，所以喚醒它嘗試獲取一波鎖，當再次調(diào)用到shouldParkAfterFailedAcquire(判斷是否應(yīng)該阻塞的方法時)會把CANCELLED狀態(tài)的節(jié)點從隊列中刪除

獨占鎖的釋放

獨占鎖是釋放其實就是利用cas將state-1，當state=0表示鎖被釋放，需要將阻塞隊列中的線程喚醒

// 調(diào)用ReentrantLock#unlock方法其實就是調(diào)用release(1) 
public final boolean release(int arg) { 
 // 嘗試釋放鎖 
 // 當state=0，表示鎖被釋放，tryRelease返回true，此時需要喚醒阻塞隊列中的線程 
 if (tryRelease(arg)) { 
  Node h = head; 
  if (h != null && h.waitStatus != 0) 
   unparkSuccessor(h); 
  return true; 
 } 
 return false; 
} 

「tryRelease即具體的解鎖邏輯，需要子類自己去實現(xiàn)」

「喚醒同步隊列中的線程，可以看到前面加了判斷h != null && h.waitStatus != 0」

h = null，說明同步同步隊列中沒有數(shù)據(jù)，則不需要喚醒 h = null && waitStatus = 0，同步隊列是有了，但是沒有線程給自己上鬧鐘，不用喚醒 h != null && waitStatus < 0，說明頭節(jié)點被人上了鬧鐘，自己需要喚醒阻塞的線程 h != null && waitStatus > 0，頭節(jié)點因為發(fā)生異常被設(shè)置為取消，但還是得喚醒線程

private void unparkSuccessor(Node node) { 
 
 int ws = node.waitStatus; 
 if (ws < 0) 
  compareAndSetWaitStatus(node, ws, 0); 
 
 // 頭結(jié)點的下一個節(jié)點 
 Node s = node.next; 
 // 為空或者被取消 
 if (s == null || s.waitStatus > 0) { 
  s = null; 
  // 從隊列尾部向前遍歷找到最前面的一個waitStatus<=0的節(jié)點 
  for (Node t = tail; t != null && t != node; t = t.prev) 
   if (t.waitStatus <= 0) 
    s = t; 
 } 
 if (s != null) 
  // 喚醒節(jié)點,但并不表示它持有鎖，要從阻塞的地方開始運行 
  LockSupport.unpark(s.thread); 
} 

「為什么要從后向前找第一個非CANCELLED的節(jié)點呢?」

private Node addWaiter(Node mode) { 
    Node node = new Node(Thread.currentThread(), mode); 
    // Try the fast path of enq; backup to full enq on failure 
    Node pred = tail; 
    if (pred != null) { 
        node.prev = pred; 
        if (compareAndSetTail(pred, node)) { 
         // 線程在這里掛起了 
            pred.next = node; 
            return node; 
        } 
    } 
    enq(node); 
    return node; 
} 

這其實和入隊的邏輯有關(guān)系，假如Node1在圖示位置掛起了，Node1后面又陸續(xù)增加了Node2和Node3，如果此時從前向后遍歷會導(dǎo)致元素丟失，不能正確喚醒線程

分析一下獨占鎖響應(yīng)中斷和不響應(yīng)中斷的區(qū)別

我們之前說過獨占鎖可以響應(yīng)中斷，也可以不響應(yīng)中斷，調(diào)用的方法如下?

1. 不響應(yīng)中斷的獨占鎖(acquire)
2. 響應(yīng)中斷的獨占鎖(acquireInterruptibly)

所以我們只需要看這2個方法的區(qū)別在哪里就可以，我下面只列出有區(qū)別的部分哈。

public final void acquire(int arg) { 
    if (!tryAcquire(arg) && 
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 
        selfInterrupt(); 
} 

public final void acquireInterruptibly(int arg) 
        throws InterruptedException { 
    // 判斷線程是否被中斷 
    if (Thread.interrupted()) 
        throw new InterruptedException(); 
    if (!tryAcquire(arg)) 
        doAcquireInterruptibly(arg); 
} 

「acquire在嘗試獲取鎖的時候完全不管線程有沒有被中斷，而acquireInterruptibly在嘗試獲取鎖之前會判斷線程是否被中斷，如果被中斷，則直接拋出異常?！?/p>

tryAcquire方法一樣，所以我們只需要對比acquireQueued方法和doAcquireInterruptibly方法的區(qū)別即可

「執(zhí)行acquireQueued方法當線程發(fā)生中斷時，只是將interrupted設(shè)置為true，并且調(diào)用selfInterrupt方法將中斷標志位設(shè)置為true」

「而執(zhí)行doAcquireInterruptibly方法，當線程發(fā)生中斷時，直接拋出異常?！?/p>

最后看一下parkAndCheckInterrupt方法，這個方法中判斷線程是否中斷的邏輯特別巧!

private final boolean parkAndCheckInterrupt() { 
 LockSupport.park(this); 
 return Thread.interrupted(); 
} 

「Thread類提供了如下2個方法來判斷線程是否是中斷狀態(tài)」

1. isInterrupted
2. interrupted

「這里為什么用interrupted而不是isInterrupted的呢?」

演示一下這2個方法的區(qū)別

@Test 
public void testInterrupt() throws InterruptedException { 
    Thread thread = new Thread(() -> { 
        while (true) {} 
    }); 
    thread.start(); 
    TimeUnit.MICROSECONDS.sleep(100); 
    thread.interrupt(); 
    // true 
    System.out.println(thread.isInterrupted()); 
    // true 
    System.out.println(thread.isInterrupted()); 
    // true 
    System.out.println(thread.isInterrupted()); 
} 

@Test 
public void testInterrupt2() { 
    Thread.currentThread().interrupt(); 
    // true 
    System.out.println(Thread.interrupted()); 
    // false 
    System.out.println(Thread.interrupted()); 
    // false 
    System.out.println(Thread.interrupted()); 
} 

「isInterrupted和interrupted的方法區(qū)別如下」

Thread#isInterrupted：測試線程是否是中斷狀態(tài)，執(zhí)行后不更改狀態(tài)標志 Thread#interrupted：測試線程是否是中斷狀態(tài)，執(zhí)行后將中斷標志更改為false

接著再寫2個例子

public static void main(String[] args) { 
 LockSupport.park(); 
 // end被一直阻塞沒有輸出 
 System.out.println("end"); 
} 

public static void main(String[] args) { 
 Thread.currentThread().interrupt(); 
 LockSupport.park(); 
 // 輸出end 
 System.out.println("end"); 
} 

可以看到當線程被中斷時，調(diào)用park()方法并不會被阻塞

public static void main(String[] args) { 
 Thread.currentThread().interrupt(); 
 LockSupport.park(); 
 // 返回中斷狀態(tài)，并且清除中斷狀態(tài) 
 Thread.interrupted(); 
 // 輸出start 
 System.out.println("start"); 
 LockSupport.park(); 
 // end被阻塞，沒有輸出 
 System.out.println("end"); 
} 

到這我們就能理解為什么要進行中斷的復(fù)位了

• 如果當前線程是非中斷狀態(tài)，則在執(zhí)行park時被阻塞，返回中斷狀態(tài)false
• 如果當前線程是中斷狀態(tài)，則park方法不起作用，返回中斷狀態(tài)true，interrupted將中斷復(fù)位，變?yōu)閒alse
• 再次執(zhí)行循環(huán)的時候，前一步已經(jīng)在線程的中斷狀態(tài)進行了復(fù)位，則再次調(diào)用park方法時會阻塞

「所以這里要對中斷進行復(fù)位，是為了不讓循環(huán)一直執(zhí)行，讓當前線程進入阻塞狀態(tài)，如果不進行復(fù)位，前一個線程在獲取鎖之后執(zhí)行了很耗時的操作，那當前線程豈不是要一直執(zhí)行死循環(huán)，造成CPU使用率飆升?」

獨占鎖的獲取和釋放我們已經(jīng)搞清楚了，共享鎖的獲取和釋放我們放到分析CountDownLatch源碼的那一節(jié)來分析

基于AQS自己寫一個鎖

你看AQS已經(jīng)把入隊，出隊，阻塞，喚醒的操作都封裝好了，當我們用AQS來實現(xiàn)自己的鎖時，就非常的方便了，只需要重寫加鎖和解鎖的邏輯即可。我這里演示一個基于AQS實現(xiàn)的非重入的互斥鎖

public class MyLock { 
 
    private final Sync sync; 
 
    public MyLock() { 
        sync = new Sync(); 
    } 
 
    public class Sync extends AbstractQueuedSynchronizer { 
 
        @Override 
        protected boolean tryAcquire(int arg) { 
            return compareAndSetState(0, arg); 
        } 
 
        @Override 
        protected boolean tryRelease(int arg) { 
            setState(0); 
            return true; 
        } 
 
    } 
 
    public void lock() { 
        sync.acquire(1); 
    } 
 
    public void unLock() { 
        sync.release(1); 
    } 
} 

本文轉(zhuǎn)載自微信公眾號「Java識堂」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系Java識堂公眾號。