干货,深入剖析ReentrantLock源码,推荐收藏

ReentrantLock和Synchronized都是Java开发中最常用的锁,与Synchronized这种JVM内置锁不同的是,ReentrantLock提供了更丰富的语义。可以创建公平锁或非公平锁、响应中断、超时等待、按条件唤醒等。在某些场景下,使用ReentrantLock更适合,功能更强大。

前两篇文章,我们分析了AQS的加锁流程、以及源码实现。当时我们就说了,AQS使用了模板设计模式,父类中定义加锁流程,子类去实现具体的加锁逻辑。所以大部分加锁代码已经在父类AQS中实现了,导致ReentrantLock的源码非常简单,一块学习一下。

先看一下ReentrantLock怎么使用?

1. ReentrantLock的使用

/**  * @author 一灯架构  * @apiNote ReentrantLock示例  **/ public class ReentrantLockDemo {          public static void main(String[] args) {         // 1. 创建ReentrantLock对象         ReentrantLock lock = new ReentrantLock();         // 2. 加锁         lock.lock();         try {             // 3. 这里执行具体的业务逻辑         } finally {             // 4. 释放锁             lock.unlock();         }     } } 

可以看到ReentrantLock的使用非常简单,调用lock加锁,unlock释放锁,需要配置try/finally使用,保证在代码执行出错的时候也能释放锁。

ReentrantLock也可以配合Condition条件使用,具体可以翻一下前几篇文章中BlockingQueue的源码解析,那里面有ReentrantLock的实际使用。

再看一下ReentrantLock的类结构

2. ReentrantLock类结构

// 实现Lock接口 public class ReentrantLock implements Lock {      // 只有一个Sync同步变量     private final Sync sync;      // Sync继承自AQS,主要逻辑都在这里面     abstract static class Sync extends AbstractQueuedSynchronizer {     }      // Sync的两个子类,分别实现了公平锁和非公平锁     static final class FairSync extends Sync {     }     static final class NonfairSync extends Sync {     }  } 

可以看出ReentrantLock的类结构非常简单,实现了Lock接口。

类里面有两个静态内部类,分别实现公平锁和非公平锁。

看一下Lock接口中,定义了哪些方法?

public interface Lock {      // 加锁     void lock();      // 加可中断的锁     void lockInterruptibly() throws InterruptedException;      // 尝试加锁     boolean tryLock();      // 一段时间内,尝试加锁     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;      // 释放锁     void unlock();      // 新建条件状态     Condition newCondition(); } 

就是一些使用锁的常用方法。

在上篇文章中浏览AQS源码的时候,了解到AQS定义了一些有关具体加锁、释放锁的抽象方法,留给子类去实现,再看一下有哪些抽象方法:

// 加独占锁 protected boolean tryAcquire(int arg) {     throw new UnsupportedOperationException(); } // 释放独占锁 protected boolean tryRelease(int arg) {     throw new UnsupportedOperationException(); }  // 加共享锁 protected int tryAcquireShared(int arg) {     throw new UnsupportedOperationException(); } // 释放共享锁 protected boolean tryReleaseShared(int arg) {     throw new UnsupportedOperationException(); }  // 判断是否是当前线程正在持有锁 protected boolean isHeldExclusively() {     throw new UnsupportedOperationException(); } 

由于ReentrantLock使用的是独占锁,所以只需要实现独占锁相关的方法就可以了。

3. ReentrantLock源码解析

3.1 ReentrantLock构造方法

// 默认的构造方法,使用非公平锁 public ReentrantLock() {     sync = new NonfairSync(); }  // 传true,可以指定使用公平锁 public ReentrantLock(boolean fair) {     sync = fair ? new FairSync() : new NonfairSync(); } 

在创建ReentrantLock对象的时候,可以指定使用公平锁还是非公平锁,默认使用非公平锁,显然非公平锁的性能更好。

先思考一个面试常考问题,公平锁和非公平锁是怎么实现的?

3.2 非公平锁源码

先看一下加锁源码:

从父类ReentrantLock的加锁方法入口:

public class ReentrantLock implements Lock {     // 加锁入口方法     public void lock() {         // 调用Sync中加锁方法         sync.lock();     } } 

在子类NonfairSync的加锁方法:

// 非公平锁 static final class NonfairSync extends Sync {      // 加锁     final void lock() {         // 1. 先尝试加锁(使用CAS设置state=1)         if (compareAndSetState(0, 1))             // 2. 加锁成功,就把当前线程设置为持有锁线程             setExclusiveOwnerThread(Thread.currentThread());         else             // 3. 没加锁成功,再调用父类AQS中实际的加锁逻辑             acquire(1);     } } 

加锁逻辑也很简单,先尝试使用CAS加锁(也就是把state从0设置成1),加锁成功,就把当前线程设置为持有锁线程。

设计者很聪明,在锁竞争不激烈的情况下,很大概率可以加锁成功,也就不用走else中复杂的加锁逻辑了。

如果没有加锁成功,还是需要走else中调用父类AQS的acquire方法,而acquire又需要调用子类的tryAcquire方法。

调用链路就是下面这样:

干货,深入剖析ReentrantLock源码,推荐收藏

根据调用链路,实际的加锁逻辑在Sync.nonfairTryAcquire方法里面。

abstract static class Sync extends AbstractQueuedSynchronizer {     // 非公平锁的最终加锁方法     final boolean nonfairTryAcquire(int acquires) {         final Thread current = Thread.currentThread();         // 1. 获取同步状态         int c = getState();         // 2. state=0表示无锁,先尝试加锁(使用CAS设置state=1)         if (c == 0) {             if (compareAndSetState(0, acquires)) {                 // 3. 加锁成功,就把当前线程设置为持有锁线程                 setExclusiveOwnerThread(current);                 return true;             }             // 4. 如果当前线程已经持有锁,执行可重入的逻辑         } else if (current == getExclusiveOwnerThread()) {             // 5. 加锁次数+acquires             int nextc = c + acquires;             // 6. 超过tnt类型最大值,溢出了             if (nextc < 0)                 throw new Error("Maximum lock count exceeded");             setState(nextc);             return true;         }         return false;     } } 

再看一下释放锁的调用流程,公平锁和非公平锁流程是一样的,最终都是执行Sync.tryRelease方法:

干货,深入剖析ReentrantLock源码,推荐收藏

abstract static class Sync extends AbstractQueuedSynchronizer {     // 释放锁     protected final boolean tryRelease(int releases) {         // 1. 同步状态减去释放锁次数         int c = getState() - releases;         // 2. 校验当前线程不持有锁,就报错         if (Thread.currentThread() != getExclusiveOwnerThread())             throw new IllegalMonitorStateException();         boolean free = false;         // 3. 判断同步状态是否等于0,无锁后,就删除持有锁的线程         if (c == 0) {             free = true;             setExclusiveOwnerThread(null);         }         setState(c);         return free;     } } 

再看一下公平锁的源码

3.3 公平锁源码

先看一下公平锁的加锁流程:

干货,深入剖析ReentrantLock源码,推荐收藏

最终的加锁方法是FairSync.tryAcquire,看一下具体逻辑:

static final class FairSync extends Sync {      // 实现父类的加锁逻辑     protected final boolean tryAcquire(int acquires) {         final Thread current = Thread.currentThread();         // 1. 获取同步状态         int c = getState();         // 2. state=0表示无锁,先尝试加锁(使用CAS设置state=1)         if (c == 0) {             // 3. 判断当前线程是不是头节点的下一个节点(讲究先来后到)             if (!hasQueuedPredecessors() &&                     compareAndSetState(0, acquires)) {                 setExclusiveOwnerThread(current);                 return true;             }             // 4. 如果当前线程已经持有锁,执行可重入的逻辑         } else if (current == getExclusiveOwnerThread()) {             // 5. 加锁次数+acquires             int nextc = c + acquires;             // 6. 超过tnt类型最大值,溢出了             if (nextc < 0)                 throw new Error("Maximum lock count exceeded");             setState(nextc);             return true;         }         return false;     }      // 判断当前线程是不是头节点的下一个节点(讲究先来后到)     public final boolean hasQueuedPredecessors() {         Node t = tail;         Node h = head;         Node s;         return h != t &&                 ((s = h.next) == null || s.thread != Thread.currentThread());     } } 

公平锁的释放锁逻辑跟非公平锁一样,上面已经讲过。

4. 总结

看完了ReentrantLock的所有源码,是不是觉得ReentrantLock很简单。

由于加锁流程的编排工作已经在父类AQS中实现,子类只需要实现具体的加锁逻辑即可。

加锁逻辑也很简单,也就是修改同步状态state的值和持有锁的线程exclusiveOwnerThread。

我是「一灯架构」,如果本文对你有帮助,欢迎各位小伙伴点赞、评论和关注,感谢各位老铁,我们下期见

干货,深入剖析ReentrantLock源码,推荐收藏

发表评论

相关文章