Java多线程分析-ReentrantLock

Field

final Sync sync;

• 核心Field，实际锁相关操作均在这里，实际上是对ReentrantLock的包装

方法

lock()

• 获取锁操作，直接委托给sync，有公平和非公平两种实现，具体看NonfairSync和FairSync

public void lock() {
    sync.lock();
}

lockInterruptibly()

• 支持中断的获取锁

public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

tryLock()

• 非阻塞方式获取锁

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

tryLock(long timeout, TimeUnit unit)

• 带有超时的获取锁

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

unlock()

• 释放锁

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

newCondition()

• 创建条件变量

public Condition newCondition() {
    return sync.newCondition();
}

getHoldCount()

• 当前线程持有锁的个数

public int getHoldCount() {
    return sync.getHoldCount();
}

isHeldByCurrentThread()

• 锁是否被当前线程支持

public boolean isHeldByCurrentThread() {
    return sync.isHeldExclusively();
}

isLocked()

• 是否处于锁定状态

public boolean isLocked() {
    return sync.isLocked();
}

isFair()

• 是否为公平锁

public final boolean isFair() {
    return sync instanceof FairSync;
}

getOwner()

• 持有锁的线程

protected Thread getOwner() {
    return sync.getOwner();
}

hasQueuedThreads()

• 是否有线程在等待获取锁

public final boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
}

hasQueuedThread(Thread thread)

• 线程是否在等待获取锁的队列中

public final boolean hasQueuedThread(Thread thread) {
    return sync.isQueued(thread);
}

getQueueLength()

• 等待队列的长度

public final int getQueueLength() {
    return sync.getQueueLength();
}

getQueuedThreads()

• 等待的线程集合

protected Collection<Thread> getQueuedThreads() {
    return sync.getQueuedThreads();
}

hasWaiters(Condition condition)

• 是否有线程阻塞在condition的await()的方法上

public boolean hasWaiters(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}

getWaitQueueLength(Condition condition)

• 阻塞在condition的await()的方法上的线程数量

public int getWaitQueueLength(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}

getWaitingThreads(Condition condition)

• 阻塞在condition的await()的方法上的线程集合

protected Collection<Thread> getWaitingThreads(Condition condition) {
    if (condition == null)
        throw new NullPointerException();
    if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
        throw new IllegalArgumentException("not owner");
    return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}

内部类

内部类有三个，公共抽象类Sync，非公平锁实现NonfairSync，公平锁实现FairSync，下面分别进行分析

Sync

void lock()

• 核心加锁方法，因为公平锁和非公平锁实现不同，所以这里为抽象方法。

boolean nonfairTryAcquire(int acquires)

• 非公平获取锁(资源)的实际实现，从以下源码可以看出，获取锁的时候，哪个先来，哪个就可以获取到，CAS操作成功的就获取到锁了，没有所谓的先来后到。

  final boolean nonfairTryAcquire(int acquires) {
      final Thread current = Thread.currentThread();//当前线程
      int c = getState();//获取加锁状态
      if (c == 0) {//为0则代表还没有上锁
          if (compareAndSetState(0, acquires)) {//执行CAS操作并且上锁
              setExclusiveOwnerThread(current);//设置持有锁的线程
              return true;//加锁成功
          }
      }
      else if (current == getExclusiveOwnerThread()) {//执行到这里说明已经有某个线程获取到锁了，因为是可重入锁，判断持有锁的线程是否为当前线程
          int nextc = c + acquires;//执行到这里说明是已经不是第一次上锁，并且当前线程是锁的持有线程，则可以直接进行累加(也就是重入)
          if (nextc < 0) // 额，超过int的最大值，出现溢出了(真的存在这种场景么= =？？)
              throw new Error("Maximum lock count exceeded");
          setState(nextc);//更新state
          return true;
      }
      return false;//获取失败
  }

boolean tryRelease(int releases)

• 非阻塞方式尝试释放资源，具体看源码分析

  protected final boolean tryRelease(int releases) {
      int c = getState() - releases;//待更新资源
      if (Thread.currentThread() != getExclusiveOwnerThread())//判断是否为锁的持有现成
          throw new IllegalMonitorStateException();
      boolean free = false;//释放标识位置。为true则代表当前线程不再持有当前锁的任何资源
      if (c == 0) {//如果释放资源后，资源数量为0，代表释放锁，其他线程可以尝试获取锁，如果不为0，则需要继续释放(因为是重入多次，需要释放多次)
          free = true;
          setExclusiveOwnerThread(null);//清空锁持有线程
      }
      setState(c);//更新状态标志位
      return free;
  }

boolean isHeldExclusively()

• 判断当前线程是否为锁持有线程

  protected final boolean isHeldExclusively() {
      return getExclusiveOwnerThread() == Thread.currentThread();
  }

ConditionObject newCondition()

• 创建条件变量对象,ConditionObject之后分析

  final ConditionObject newCondition() {
      return new ConditionObject();
  }

Thread getOwner()

• 如果锁没有被线程持有，返回null，否则返回持有的线程

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

int getHoldCount()

• 获取重入次数。如果当前线程没有持有锁，返回0；

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

boolean isLocked()

• 是否处于锁定状态

  final boolean isLocked() {
      return getState() != 0;
  }

NonfairSync

• 非公平锁的委托实现，继承了Sync类，间接继承了AQS

void lock()

• 获取锁操作，直接通过cas获取，失败则通过aqs的acquire获取，acquire在父类AQS中，会调用子类的tryAcquire方法。

  final void lock() {
      if (compareAndSetState(0, 1))
          setExclusiveOwnerThread(Thread.currentThread());
      else
          acquire(1);
  }
  
  public final void acquire(int arg) {
      if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          selfInterrupt();
  }

boolean tryAcquire(int acquires)

• 直接调用sync抽象类中的nonfairTryAcquire，非公平方式获取资源

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

FairSync

• 公平锁的委托实现，继承了Sync类，间接继承了AQS

void lock()

• 没有快速路径，直接调用acquire去获取资源，内部委托依旧是调用tryAcquire

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

boolean tryAcquire(int acquires)

• 与非公平获取资源相比，区别在于多了条件!hasQueuedPredecessors() ，也就是说按照队列的方式获取，如果队列中尚有未获取的在等待，则当前线程等待并且入队(参考AQS部分)

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

总结

• 其实相对而言，可重入锁实现很简单，基本都是继承了AQS的方法，重点实现了可重入(线程相同则累加state)，以及公平非公平。
• 重点还是在于理解AQS，这里的可重入锁，以及之后的可重入读写锁,CountDownLatch，Semaphore,CyclicBarrier等都是基于AQS实现的。