Java并发源码之ReentrantLock(一)

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

版权声明：本文为博主原创文章，转载请注明出处：http://blog.jerkybible.com/2017/09/29/Java并发源码之ReentrantLock-一/

访问原文「Java并发源码之ReentrantLock(一)」

ReentrantLock介绍

ReentrantLock是一个可重入的互斥锁，与使用synchronized方法和语句访问的隐式监视锁具有相同的基本行为和语义，但具有扩展功能。ReentrantLock属于最后一个成功加锁并且还没有释放锁的线程。当一个线程请求lock时，如果锁不属于任何线程，将立马得到这个锁；如果锁已经被当前线程拥有，当前线程会立即返回。

下面这个图是与ReentrantLock相关的UML类图，可以看到ReentrantLock实现了Lock和Serializable接口，表示它实现了lock()、unlock()等Lock的接口方法，并且是一个可以序列化的类。ReentrantLock主要成员变量为Sync，Sync是一个抽象类，继承了AbstractQueuedSynchronizer（简称AQS），AQS提供了一个基于FIFO队列，可以用于构建锁或者其他相关同步装置的基础框架，本文不详细介绍。而Sync有两个实现类：NonfairSync和FairSync，分别代表非公平锁和公平锁。也就是说ReentrantLock中所有的锁操作都是由sync这个成员变量完成的。

ReentrantLock构造方法

下面的代码为它的构造函数，可以看到无参构造函数直接返回非公平锁。

/**
 * 创建一个ReentrantLock实例
 * 等同于调用ReentrantLock(false).
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * 根据公平策略创建一个ReentrantLock实例
 *
 * @param fair 如果采用公平锁则为true
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

ReentrantLock加锁方法

下面是三个常用的ReentrantLock加锁方法，分别为lock、tryLock、lockInterruptibly。

/**
 * 获得锁.
 *
 * 如果锁没有被另一个线程保持并且立即返回，则将锁定计数设置为1
 *
 * 如果当前线程已经保持锁定，则保持计数增加1，该方法立即返回
 *
 * 如果锁被另一个线程保持，则为了进行线程调度将当前线程禁用，
 * 并且在锁定被获取之前处于休眠状态，此时锁定保持计数被设置为1
 */
public void lock() {
    sync.lock();
}

/**
 * 只有在调用时它不被另一个线程占用才能获取锁
 *
 * 如果没有被另一个线程占用，则获取锁定，并立即返回true，将锁定保持计数设置为1
 *
 * 即使此锁已设置为使用合理的排序策略，如果锁可用，则调用tryLock将立即获取锁定，
 * 无论其他线程是否正在等待锁
 *
 * 这种行为尽管打破了公平，但是在某些情况下是有用的。如果要遵守此锁的公平性设置，
 * 请使用几乎相等的tryLock(long，TimeUnit)
 *
 * 如果当前线程已经保存该锁，则保持计数增加1，该方法返回true
 * 如果锁由另一个线程保存，则该方法将立即返回值为false
 *
 * @return 如果锁是空闲的并且被当前线程获取，或者锁已经被当前线程占据,返回true；
 *         否则返回false
 */
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

/**
  * 获取锁定，除非当前的线程被中断
  *
  * 如果锁没有被另一个线程保持并且立即返回，则将锁定计数设置为1
  *
  * 如果当前线程已经保存此锁，则保持计数增加1，该方法立即返回
  *
  * 如果锁被另一个线程保持，则当前线程将被禁用以进行线程调度，并且休眠，
  * 直到发生两件事情之一:
  *     1. 当前线程获取锁
  *     2. 一些其他线程中断当前线程
  *
  * 如果当前线程获取锁定，则锁定保持计数设置为1。
  *
  * 如果当前的线程：
  *     1. 在进入此方法时设置了中断状态
  *     2. 在获取锁时中断
  * 则抛出InterruptedException并清除当前线程的中断状态
  *
  * 在该实现中，由于该方法是明确的中断点，所以优先考虑响应中断超过正常或可重入的锁定
  *
  * @throws InterruptedException 如果当前线程中断
  */
 public void lockInterruptibly() throws InterruptedException {
     sync.acquireInterruptibly(1);
 }

上面代码的注释已经很明白，这里我总结一下：

1. lock：拿不到lock就不会结束，不然线程就一直等待
2. tryLock：马上返回，拿到lock返回true，否则返回false
3. lockInterruptibly：线程在请求lock并被阻塞时，如果被中断，则此线程会被唤醒并被要求处理InterruptedException。并且如果线程已经被interrupt，再使用lockInterruptibly的时候，此线程也会被要求处理interruptedException

ReentrantLock释放锁方法

ReentrantLock的释放锁方法比较简单，只有一个unlock。下面是它的说明。

/**
 * 尝试释放此锁
 *
 * 如果当前线程是该锁的持有者，则保持计数递减。 如果保持计数现在为零，则锁定被释放。
 * 如果当前线程不是此锁的持有者，则会抛出IllegalMonitorStateException
 *
 * @throws IllegalMonitorStateException 如果当前线程不是此锁的持有者
 */
public void unlock() {
    sync.release(1);
}

ReentrantLock其他方法

下面列出了ReentrantLock的其他方法都比较好理解。

/**
 * 返回一个与此Lock实例一起使用的Condition实例.
 *
 * Condition将Object监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，
 * 以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待 set（wait-set）。
 * 其中，Lock替代了synchronized方法和语句的使用，
 * Condition替代了Object监视器方法的使用。
 *
 *
 * @return Condition实例
 */
public Condition newCondition() {
    return sync.newCondition();
}

/**
 * 查询当前线程对此锁的持有数量.
 *
 * 一个线程对于与无解锁每个锁定动作都持有一个锁定
 *
 * @return 当前线程对此锁定的保持数，如果此锁定不被当前线程占用，则为零
 */
public int getHoldCount() {
    return sync.getHoldCount();
}
/**
 * 查询此锁是否由当前线程持有.
 *
 * @return 如果当前线程持有此锁，则为true，否则为false
 */
public boolean isHeldByCurrentThread() {
    return sync.isHeldExclusively();
}
/**
 * 查询此锁是否由任何线程持有。 该方法设计用于监视系统状态，不用于同步控制.
 *
 * @return 如果当前线程持有此锁，则为true，否则为false
 */
public boolean isLocked() {
    return sync.isLocked();
}

/**
 * 如果此锁的公平设置为true，则返回true。
 *
 * @return 如果此锁的公平设置为true，则返回true。
 */
public final boolean isFair() {
    return sync instanceof FairSync;
}

/**
 * 返回当前拥有该锁的线程，如果不拥有则返回null
 *
 * @return 返回当前拥有该锁的线程，如果不拥有则返回null
 */
protected Thread getOwner() {
    return sync.getOwner();
}

/**
 * 查询是否有线程正在等待获取此锁
 *
 * @return 如果可能有其他线程等待获取锁则返回true
 */
public final boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
}

/**
 * 查询给定的线程是否等待获取此锁
 *
 * @param thread 给定的线程
 * @return 给定的线程如果等待获取此锁则返回true
 * @throws NullPointerException 给定的线程为null
 */
public final boolean hasQueuedThread(Thread thread) {
    return sync.isQueued(thread);
}

/**
 * 返回等待获取此锁的线程数的估计
 *
 * @return 返回等待获取此锁的线程数的估计
 */
public final int getQueueLength() {
    return sync.getQueueLength();
}

/**
 * 返回一个包含可能正在等待获取此锁的线程的集合
 *
 * @return 包含线程的集合
 */
protected Collection<Thread> getQueuedThreads() {
    return sync.getQueuedThreads();
}

/**
 * 查询是否有任何线程正在等待与此锁相关联的给定condition
 *
 * @param condition Condition实例
 * @return 如果有任何等待线程，则为true
 * @throws IllegalMonitorStateException 如果没有持有锁
 * @throws IllegalArgumentException condition没有与锁相关联
 * @throws NullPointerException condition为null
 */
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);
}

/**
 * 返回与此锁相关联的给定condition等待的线程数的估计
 *
 * @param condition Condition实例
 * @return 估计数量
 * @throws IllegalMonitorStateException 如果没有持有锁
 * @throws IllegalArgumentException condition没有与锁相关联
 * @throws NullPointerException condition为null
 */
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);
}

/**
 * 返回包含可能在与此锁相关联的给定condition下等待的线程的集合
 *
 * @param condition Condition实例
 * @return 线程集合
 * @throws IllegalMonitorStateException 如果没有持有锁
 * @throws IllegalArgumentException condition没有与锁相关联
 * @throws NullPointerException condition为null
 */
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);
}

总结一下

本文仅仅是对ReentrantLock做了简单的介绍，包括主要结构和主要方法。通过上面的描述可以看到，ReentrantLock所有的方法都交给了它的sync成员变量来完成。接下来将会对公平锁和非公平锁进行分析。