Java并发系列之AbstractQueuedSynchronizer源码分析（独占模式）

//不响应中断方式获取(独占模式)
public final void acquire(int arg) {
  if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
    selfInterrupt();
  }
}

 //尝试去获取锁(独占模式)
protected boolean tryAcquire(int arg) {
  throw new UnsupportedOperationException();
}

//将当前线程包装成结点并添加到同步队列尾部
private Node addWaiter(Node mode) {
  //指定持有锁的模式
  Node node = new Node(Thread.currentThread(), mode);
  //获取同步队列尾结点引用
  Node pred = tail;
  //如果尾结点不为空, 表明同步队列已存在结点
  if (pred != null) {
    //1.指向当前尾结点
    node.prev = pred;
    //2.设置当前结点为尾结点
    if (compareAndSetTail(pred, node)) {
      //3.将旧的尾结点的后继指向新的尾结点
      pred.next = node;
      return node;
    }
  }
  //否则表明同步队列还没有进行初始化
  enq(node);
  return node;
}

//结点入队操作
private Node enq(final Node node) {
  for (;;) {
    //获取同步队列尾结点引用
    Node t = tail;
    //如果尾结点为空说明同步队列还没有初始化
    if (t == null) {
      //初始化同步队列
      if (compareAndSetHead(new Node())) {
        tail = head;
      }
    } else {
      //1.指向当前尾结点
      node.prev = t;
      //2.设置当前结点为尾结点
      if (compareAndSetTail(t, node)) {
        //3.将旧的尾结点的后继指向新的尾结点
        t.next = node;
        return t;
      }
    }
  }
}

//以不可中断方式获取锁(独占模式)
final boolean acquireQueued(final Node node, int arg) {
  boolean failed = true;
  try {
    boolean interrupted = false;
    for (;;) {
      //获取给定结点的前继结点的引用
      final Node p = node.predecessor();
      //如果当前结点是同步队列的第一个结点, 就尝试去获取锁
      if (p == head && tryAcquire(arg)) {
        //将给定结点设置为head结点
        setHead(node);
        //为了帮助垃圾收集, 将上一个head结点的后继清空
        p.next = null;
        //设置获取成功状态
        failed = false;
        //返回中断的状态, 整个循环执行到这里才是出口
        return interrupted;
      }
      //否则说明锁的状态还是不可获取, 这时判断是否可以挂起当前线程
      //如果判断结果为真则挂起当前线程, 否则继续循环, 在这期间线程不响应中断
      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        interrupted = true;
      }
    }
  } finally {
    //在最后确保如果获取失败就取消获取
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//判断是否可以将当前结点挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  //获取前继结点的等待状态
  int ws = pred.waitStatus;
  //如果前继结点状态为SIGNAL, 表明前继结点会唤醒当前结点, 所以当前结点可以安心的挂起了
  if (ws == Node.SIGNAL) {
    return true;
  }
  
  if (ws > 0) {
    //下面的操作是清理同步队列中所有已取消的前继结点
    do {
      node.prev = pred = pred.prev;
    } while (pred.waitStatus > 0);
    pred.next = node;
  } else {
    //到这里表示前继结点状态不是SIGNAL, 很可能还是等于0, 这样的话前继结点就不会去唤醒当前结点了
    //所以当前结点必须要确保前继结点的状态为SIGNAL才能安心的挂起自己
    compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
  }
  return false;
}

//挂起当前线程
private final boolean parkAndCheckInterrupt() {
  LockSupport.park(this);
  return Thread.interrupted();
}

 //当前线程将自己中断
 private static void selfInterrupt() {
   Thread.currentThread().interrupt();
 }

//以可中断模式获取锁(独占模式)
private void doAcquireInterruptibly(int arg) throws InterruptedException {
  //将当前线程包装成结点添加到同步队列中
  final Node node = addWaiter(Node.EXCLUSIVE);
  boolean failed = true;
  try {
    for (;;) {
      //获取当前结点的前继结点
      final Node p = node.predecessor();
      //如果p是head结点, 那么当前线程就再次尝试获取锁
      if (p == head && tryAcquire(arg)) {
        setHead(node);
        p.next = null; // help GC
        failed = false;
        //获取锁成功后返回
        return;
      }
      //如果满足条件就挂起当前线程, 此时响应中断并抛出异常
      if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        //线程被唤醒后如果发现中断请求就抛出异常
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//以限定超时时间获取锁(独占模式)
private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
  //获取系统当前时间
  long lastTime = System.nanoTime();
  //将当前线程包装成结点添加到同步队列中
  final Node node = addWaiter(Node.EXCLUSIVE);
  boolean failed = true;
  try {
    for (;;) {
      //获取当前结点的前继结点
      final Node p = node.predecessor();
      //如果前继是head结点, 那么当前线程就再次尝试获取锁
      if (p == head && tryAcquire(arg)) {
        //更新head结点
        setHead(node);
        p.next = null;
        failed = false;
        return true;
      }
      //超时时间用完了就直接退出循环
      if (nanosTimeout <= 0) {
        return false;
      }
      //如果超时时间大于自旋时间, 那么等判断可以挂起线程之后就会将线程挂起一段时间
      if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold) {
        //将当前线程挂起一段时间, 之后再自己醒来
        LockSupport.parkNanos(this, nanosTimeout);
      }
      //获取系统当前时间
      long now = System.nanoTime();
      //超时时间每次都减去获取锁的时间间隔
      nanosTimeout -= now - lastTime;
      //再次更新lastTime
      lastTime = now;
      //在获取锁的期间收到中断请求就抛出异常
      if (Thread.interrupted()) {
        throw new InterruptedException();
      }
    }
  } finally {
    if (failed) {
      cancelAcquire(node);
    }
  }
}

//释放锁的操作(独占模式)
public final boolean release(int arg) {
  //拨动密码锁, 看看是否能够开锁
  if (tryRelease(arg)) {
    //获取head结点
    Node h = head;
    //如果head结点不为空并且等待状态不等于0就去唤醒后继结点
    if (h != null && h.waitStatus != 0) {
      //唤醒后继结点
      unparkSuccessor(h);
    }
    return true;
  }
  return false;
}

//唤醒后继结点
private void unparkSuccessor(Node node) {
  //获取给定结点的等待状态
  int ws = node.waitStatus;
  //将等待状态更新为0
  if (ws < 0) {
    compareAndSetWaitStatus(node, ws, 0);
  }
  //获取给定结点的后继结点
  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);
  }
}