JUC 八股13 - 锁4(ReentrantLock)

public class ReentrantLock implements Lock, java.io.Serializable {
  ...
  private final Sync sync;
  ...
  abstract static class Sync extends AbstractQueuedSynchronizer {
    ...
  }
  ...
  /**
   * Sync object for non-fair locks
   */
  static final class NonfairSync extends Sync {
      private static final long serialVersionUID = 7316153563782823691L;

      /**
       * Performs lock.  Try immediate barge, backing up to normal
       * acquire on failure.
       */
      @ReservedStackAccess
      final void lock() {
          if (compareAndSetState(0, 1))
              setExclusiveOwnerThread(Thread.currentThread());
          else
              acquire(1);
      }

      protected final boolean tryAcquire(int acquires) {
          return nonfairTryAcquire(acquires);
      }
  }

  /**
   * Sync object for fair locks
   */
  static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
      acquire(1);
    }

    /**
     * Fair version of tryAcquire.  Don't grant access unless
     * recursive call or no waiters or is first.
     */
    @ReservedStackAccess
    protected final boolean tryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) {
          if (!hasQueuedPredecessors() &&
              compareAndSetState(0, acquires)) {
              setExclusiveOwnerThread(current);
              return true;
          }
      }
      else if (current == getExclusiveOwnerThread()) {
          int nextc = c + acquires;
          if (nextc < 0)
              throw new Error("Maximum lock count exceeded");
          setState(nextc);
          return true;
      }
      return false;
    }
  }
  ...
  public void lock() {
    sync.lock();
  }
  ...
}

 final void lock() {
  if (compareAndSetState(0, 1))
    setExclusiveOwnerThread(Thread.currentThread());
  else
    acquire(1);
}

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

static final class NonfairSync extends Sync {
  ...
  protected final boolean tryAcquire(int acquires) {
      return nonfairTryAcquire(acquires);
  }
}

abstract static class Sync extends AbstractQueuedSynchronizer {
  private static final long serialVersionUID = -5179523762034025860L;

  /**
   * Performs {@link Lock#lock}. The main reason for subclassing
   * is to allow fast path for nonfair version.
   */
  abstract void lock();

  /**
   * Performs non-fair tryLock.  tryAcquire is implemented in
   * subclasses, but both need nonfair try for trylock method.
   */
  @ReservedStackAccess
  final boolean nonfairTryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) {
          if (compareAndSetState(0, acquires)) {
              setExclusiveOwnerThread(current);
              return true;
          }
      }
      else if (current == getExclusiveOwnerThread()) {
          int nextc = c + acquires;
          if (nextc < 0) // overflow
              throw new Error("Maximum lock count exceeded");
          setState(nextc);
          return true;
      }
      return false;
  }
  ...
}

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;
      }
  }
  // CAS 失败后，调用 enq 确保入队
  enq(node);
  return node;
}

private Node enq(final Node node) {
  for (;;) {
    Node t = tail;
    if (t == null) { // Must initialize
      if (compareAndSetHead(new Node()))
          tail = head;
    } else {
      node.prev = t;
      if (compareAndSetTail(t, node)) {
          t.next = node;
          return t;
      }
    }
  }
}

final boolean acquireQueued(final Node node, int arg) {
  // 标记是否失败，用于 finally 清理
  boolean failed = true;
  try {
    // 记录线程是否被中断过
    boolean interrupted = false;
    // 自旋
    for (;;) {
      final Node p = node.predecessor();
      // 核心判断：前驱是 head 且抢锁成功
      if (p == head && tryAcquire(arg)) {
        // 当前节点成为新 head
        setHead(node);
        // help GC
        p.next = null;
        // 标记成功
        failed = false;
        return interrupted;
      }
      // 抢锁失败，判断是否需要挂起
      if (shouldParkAfterFailedAcquire(p, node) &&
        parkAndCheckInterrupt())
        interrupted = true;
    }
  } finally {
    if (failed)
      cancelAcquire(node);
  }
}

if (shouldParkAfterFailedAcquire(p, node) &&
  parkAndCheckInterrupt())
  interrupted = true;

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

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  int ws = pred.waitStatus;
  if (ws == Node.SIGNAL)
    /*
      * This node has already set status asking a release
      * to signal it, so it can safely park.
      */
    return true;
  if (ws > 0) {
    /*
      * Predecessor was cancelled. Skip over predecessors and
      * indicate retry.
      */
    do {
        node.prev = pred = pred.prev;
    } while (pred.waitStatus > 0);
    pred.next = node;
  } else {
    /*
    * waitStatus must be 0 or PROPAGATE.  Indicate that we
    * need a signal, but don't park yet.  Caller will need to
    * retry to make sure it cannot acquire before parking.
    */
    compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
  }
  return false;
}

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

@ReservedStackAccess
public final boolean release(int arg) {
  if (tryRelease(arg)) {
    Node h = head;
    if (h != null && h.waitStatus != 0)
        unparkSuccessor(h);
    return true;
  }
  return false;
}

@ReservedStackAccess
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;   
    // 先计算本次解锁之后的状态值
    if (Thread.currentThread() != getExclusiveOwnerThread())   
    // 因为是独占锁，那肯定这把锁得是当前线程持有才行
      throw new IllegalMonitorStateException();   //否则直接抛异常
    
    boolean free = false;
    if (c == 0) {  
      // 如果解锁之后的值为0，表示已经完全释放此锁
      free = true;
      setExclusiveOwnerThread(null);  
      // 将独占锁持有线程设置为null
    }
    setState(c);   // 状态值设定为c
    // 如果不是0表示此锁还没完全释放，返回false，是0就返回true
    return free;
}

@ReservedStackAccess
public final boolean release(int arg) {
  if (tryRelease(arg)) {
    Node h = head;
    if (h != null && h.waitStatus != 0)
        unparkSuccessor(h);
    return true;
  }
  return false;
}

private void unparkSuccessor(Node node) {
  /*
  * If status is negative (i.e., possibly needing signal) try
  * to clear in anticipation of signalling.  It is OK if this
  * fails or if status is changed by waiting thread.
  */
  int ws = node.waitStatus;
  if (ws < 0)
    compareAndSetWaitStatus(node, ws, 0);

  /*
  * Thread to unpark is held in successor, which is normally
  * just the next node.  But if cancelled or apparently null,
  * traverse backwards from tail to find the actual
  * non-cancelled successor.
  */
  Node s = node.next;
  if (s == null || s.waitStatus > 0) {
    s = null;
    for (Node t = tail; t != null && t != node; t = t.prev)
      if (t.waitStatus <= 0)
          s = t;
  }
  if (s != null)
    LockSupport.unpark(s.thread);
}