• AQS 初步认识
  • AQS 核心源码
• ReentrantLock
  • 成员变量和构造函数
  • 公平锁和非公平锁
  • 非公平锁 NonfairSync
  • 公平锁 FairSync
  • ReentrantLock 的公共同步器 Sync
• ReentrantReadWriteLock
  • 成员变量和构造函数
  • 读写锁的公平与非公平性
  • ReadLock 读锁

AQS 初步认识

AQS 核心源码

获取锁

public final void acquire(int arg) {
  // 尝试获取锁失败后，将当前线程加入阻塞队列
  if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
      selfInterrupt();
}

protected boolean tryAcquire(int arg) {

  // 尝试获取锁的具体逻辑由子类实现
  throw new UnsupportedOperationException();
}

释放锁

public final boolean release(int arg) {
  if (tryRelease(arg)) {
    // 尝试释放锁
    Node h = head;
    if (h != null && h.waitStatus != 0)
      // 释放后唤醒队列的头结点
      unparkSuccessor(h);
    return true;
  }
  return false;
}

ReentrantLock

成员变量和构造函数

public class ReentrantLock implements Lock {
  // 抽象同步器
  private final Sync sync;

  abstract static class Sync extends AbstractQueuedSynchronizer {}

  // 非公平锁实现
  static final class NonfairSync extends Sync {}

  // 公平锁实现
  static final class FairSync extends Sync {}

  // 默认是非公平锁
  public ReentrantLock() {
    sync = new NonfairSync();
  }

  // 可以指定公平锁
  public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
  }

}

公平锁和非公平锁

传统的误区认为公平锁是先来后到的，非公平锁是竞争抢的。其实公平锁还是非公平锁也好都是先来后到的。

公平与非公平的决定性差异在于，当线程释放时同时有队列的线程和新的线程的时候，新线程能否竞争抢锁。对于非公平锁，新线程可以参与竞争抢锁。对于公平锁，新的线程要上锁时发现队列中有线程，则不得抢锁。

所以公平与非公平锁的差异是很细微的，一般很难判断区分公平与非公平的实际运行差异。但是在高并发场景下，使用非公平锁是能够稳妥保证不会发生线程饥饿问题。

推测历史，大概一开始只实现了非公平锁，后来发现存在饥饿问题便提供扩展了公平锁实现~

非公平锁 NonfairSync

  final void lock() {
    // 先尝试自己主动CAS获取锁 如果获取成功设置当前线程独占(步骤前置优化)
    if (compareAndSetState(0, 1))
      setExclusiveOwnerThread(Thread.currentThread());
    else
      // 自己尝试的CAS失败，进入整个AQS上锁逻辑
      acquire(1);
  }

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

  // TODO 备注：这个方法实际上是写到了公共同步器Sync上的，这里为了代码结构和文章结构统一放一起讲
  final boolean nonfairTryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) { // 没有线程占用锁,可以上锁
          // CAS 让当前线程抢锁
          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;
  }

公平锁 FairSync

  final void lock() {
    // mark: 非公平锁还优化 公平锁懒得优化了
    acquire(1);
  }

  protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) { // 没有线程占用锁,可以上锁
      // 队列中是否有其他线程 如果没有才允许进行CAS抢锁 (如果有会返回false，进入AQS阻塞逻辑)
      if (!hasQueuedPredecessors() && 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;
  }

ReentrantLock 的公共同步器 Sync

释放锁逻辑是公共的

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);
  }
  // CAS设置state状态，这一步才算真正完成释放锁逻辑，允许其他线程来抢锁
  setState(c);
  return free;
}

ReentrantReadWriteLock

成员变量和构造函数

public class ReentrantReadWriteLock implements ReadWriteLock {
  
  private final ReentrantReadWriteLock.ReadLock readerLock; // 读锁
  private final ReentrantReadWriteLock.WriteLock writerLock; // 写锁

  final Sync sync; // 公共同步器

  // 默认非公平实现
  public ReentrantReadWriteLock() {
      this(false);
  }

  // 可以指定公平锁
  public ReentrantReadWriteLock(boolean fair) {
      sync = fair ? new FairSync() : new NonfairSync();
      readerLock = new ReadLock(this);
      writerLock = new WriteLock(this);
  }

  public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
  public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

  abstract static class Sync extends AbstractQueuedSynchronizer {}

  static final class NonfairSync extends Sync {}

  static final class FairSync extends Sync {}

  public static class ReadLock implements Lock {}

  public static class WriteLock implements Lock {}

}

读写锁的公平与非公平性

ReadLock 读锁

public static class ReadLock implements Lock {
  private final Sync sync;

  protected ReadLock(ReentrantReadWriteLock lock) {
    sync = lock.sync;
  }

  public void lock() {
    sync.acquireShared(1); // AQS 提供的共享锁的方法
  }

  public boolean tryLock() {
    return sync.tryReadLock();
  }

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

可以看到本身是全都委派到AQS方法上了，但这里为了文章结构，先把这些方法统一放这里看