ReentrantLock实现原理深入探究详解编程语言

private final Sync sync; 
 
    /** 
     * Base of synchronization control for this lock. Subclassed 
     * into fair and nonfair versions below. Uses AQS state to 
     * represent the number of holds on the lock. 
     */ abstract static class Sync extends AbstractQueuedSynchronizer { ...
 }

 1 final void lock() { 
 2     if (compareAndSetState(0, 1))  3  setExclusiveOwnerThread(Thread.currentThread());  4 else  5 acquire(1);  6 }

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

 1 final boolean nonfairTryAcquire(int acquires) { 
 2 final Thread current = Thread.currentThread();  3 int c = getState();  4 if (c == 0) {  5 if (compareAndSetState(0, acquires)) {  6  setExclusiveOwnerThread(current);  7 return true;  8  }  9  } 10 else if (current == getExclusiveOwnerThread()) { 11 int nextc = c + acquires; 12 if (nextc < 0) // overflow 13 throw new Error("Maximum lock count exceeded"); 14  setState(nextc); 15 return true; 16  } 17 return false; 18 }

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; }

 1 private Node enq(final Node node) { 
 2     for (;;) {  3 Node t = tail;  4 if (t == null) { // Must initialize  5 Node h = new Node(); // Dummy header  6 h.next = node;  7 node.prev = h;  8 if (compareAndSetHead(h)) {  9 tail = node; 10 return h; 11  } 12  } 13 else { 14 node.prev = t; 15 if (compareAndSetTail(t, node)) { 16 t.next = node; 17 return t; 18  } 19  } 20  } 21 }

 1 final boolean acquireQueued(final Node node, int arg) {  2 try {  3 boolean interrupted = false;  4 for (;;) {  5 final Node p = node.predecessor();  6 if (p == head && tryAcquire(arg)) {  7  setHead(node);  8 p.next = null; // help GC  9 return interrupted; 10  } 11 if (shouldParkAfterFailedAcquire(p, node) && 12  parkAndCheckInterrupt()) 13 interrupted = true; 14  } 15 } catch (RuntimeException ex) { 16  cancelAcquire(node); 17 throw ex; 18  } 19 }

 1 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { 
 2 int s = pred.waitStatus;  3 if (s < 0)  4 /*  5  * This node has already set status asking a release  6  * to signal it, so it can safely park  7 */  8 return true;  9 if (s > 0) { 10 /* 11  * Predecessor was cancelled. Skip over predecessors and 12  * indicate retry. 13 */ 14 do { 15 node.prev = pred = pred.prev; 16 } while (pred.waitStatus > 0); 17 pred.next = node; 18 } 19 else 20 /* 21  * Indicate that we need a signal, but don't park yet. Caller 22  * will need to retry to make sure it cannot acquire before 23  * parking. 24 */ 25 compareAndSetWaitStatus(pred, 0, Node.SIGNAL); 26 return false; 27 }

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

public static void park(Object blocker) { 
    Thread t = Thread.currentThread(); 
    setBlocker(t, blocker); 
    unsafe.park(false, 0L); setBlocker(t, null); }

public void unlock() { 
    sync.release(1); 
}

1 public final boolean release(int arg) { 2 if (tryRelease(arg)) { 3 Node h = head; 4 if (h != null && h.waitStatus != 0) 5  unparkSuccessor(h); 6 return true; 7  } 8 return false; 9 }

 1 protected final boolean tryRelease(int releases) {  2 int c = getState() - releases;  3 if (Thread.currentThread() != getExclusiveOwnerThread())  4 throw new IllegalMonitorStateException();  5 boolean free = false;  6 if (c == 0) {  7 free = true;  8 setExclusiveOwnerThread(null);  9  } 10  setState(c); 11 return free; 12 }

 1 private void unparkSuccessor(Node node) { 
 2     /*  3  * Try to clear status in anticipation of signalling. It is  4  * OK if this fails or if status is changed by waiting thread.  5 */  6 compareAndSetWaitStatus(node, Node.SIGNAL, 0);  7  8 /*  9  * Thread to unpark is held in successor, which is normally 10  * just the next node. But if cancelled or apparently null, 11  * traverse backwards from tail to find the actual 12  * non-cancelled successor. 13 */ 14 Node s = node.next; 15 if (s == null || s.waitStatus > 0) { 16 s = null; 17 for (Node t = tail; t != null && t != node; t = t.prev) 18 if (t.waitStatus <= 0) 19 s = t; 20  } 21 if (s != null) 22  LockSupport.unpark(s.thread); 23 }

 1 final boolean acquireQueued(final Node node, int arg) {  2 try {  3 boolean interrupted = false;  4 for (;;) {  5 final Node p = node.predecessor();  6 if (p == head && tryAcquire(arg)) {  7  setHead(node);  8 p.next = null; // help GC  9 return interrupted; 10  } 11 if (shouldParkAfterFailedAcquire(p, node) && 12  parkAndCheckInterrupt()) 13 interrupted = true; 14  } 15 } catch (RuntimeException ex) { 16  cancelAcquire(node); 17 throw ex; 18  } 19 }

private void setHead(Node node) { 
    head = node; 
    node.thread = null; node.prev = null; }

final int getHoldCount() { 
    return isHeldExclusively() ? getState() : 0; 
}

final Thread getOwner() { 
    return getState() == 0 ? null : getExclusiveOwnerThread(); 
}

public final Collection<Thread> getQueuedThreads() { 
    ArrayList<Thread> list = new ArrayList<Thread>(); 
    for (Node p = tail; p != null; p = p.prev) { Thread t = p.thread; if (t != null) list.add(t); } return list; }

public final int getQueueLength() { 
    int n = 0; for (Node p = tail; p != null; p = p.prev) { if (p.thread != null) ++n; } return n; }