ReentrantLock源码分析

ReentrantLock：表示重入锁，它是唯一一个实现了Lock接口的类。重入锁指的是 线程在获得锁之后，再次获取该锁不需要阻塞，而是直接关联一次计数器增加重入次；

syschronized和reenttrantlock都支持重入锁；

重入锁的设计目的
比如调用demo方法获得了当前的对象锁，然后在这个方法中再去调用 demo2，demo2中的存在同一个实例锁，这个时候当前线程会因为无法获得 demo2的对象锁而阻塞，就会产生死锁。重入锁的设计目的是避免线程的死 锁。

 ReentrantReadWriteLock
我们以前理解的锁，基本都是排他锁（互斥锁），也就是这些锁在同一时刻只允许一个线程进 行访问，而读写所在同一时刻可以允许多个线程访问，但是在写线程访问时，所有 的读线程和其他写线程都会被阻塞。读写锁维护了一对锁，一个读锁、一个写锁; 一般情况下，读写锁的性能都会比排它锁好，因为大多数场景读是多于写的。在读 多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量.

public class LockDemo {
 
    static Map<String,Object> cacheMap=new HashMap<>();
    static ReentrantReadWriteLock rwl=new
ReentrantReadWriteLock();
    static Lock read=rwl.readLock();
    static Lock write=rwl.writeLock();
 
    public static final Object get(String key) {
        System.out.println("开始读取数据");
        read.lock(); // 读锁
 
        try {
            return cacheMap.get(key);

 
 
        }finally {
            read.unlock();
        }
    }
    public static final Object put(String key,Object value){
        write.lock();
        System.out.println("开始写数据");
        try{
            return cacheMap.put(key,value);
        }finally {
            write.unlock();
        }
    }
}

在这个案例中，通过hashmap来模拟了一个内存缓存，然后使用读写所来保证这 个内存缓存的线程安全性。当执行读操作的时候，需要获取读锁，在并发访问的时候，读锁不会被阻塞，因为读操作不会影响执行结果。 在执行写操作是，线程必须要获取写锁，当已经有线程持有写锁的情况下，当前线 程会被阻塞，只有当写锁释放以后，其他读写操作才能继续执行。使用读写锁提升 读操作的并发性，也保证每次写操作对所有的读写操作的可见性

⚫ 读锁与读锁可以共享

⚫ 读锁与写锁不可以共享（排他）

⚫ 写锁与写锁不可以共享（排他）

ReentrantLock 的实现原理

我们知道锁的基本原理是，基于将多线程并行任务通过某一种机制实现线程的串 行执行，从而达到线程安全性的目的。在 synchronized 中，我们分析了偏向锁、 轻量级锁、乐观锁。基于乐观锁以及自旋锁来优化了 synchronized 的加锁开销， 同时在重量级锁阶段，通过线程的阻塞以及唤醒来达到线程竞争和同步的目的。 那么在ReentrantLock中，也一定会存在这样的需要去解决的问题。就是在多线程 竞争重入锁时，竞争失败的线程是如何实现阻塞以及被唤醒的呢？

AQS 是什么
在 Lock 中，用到了一个同步队列 AQS，全称 AbstractQueuedSynchronizer，它 是一个同步工具也是Lock用来实现线程同步的核心组件。如果你搞懂了AQS，那 么J.U.C中绝大部分的工具都能轻松掌握

AQS 的两种功能
从使用层面来说，AQS的功能分为两种：独占和共享 独占锁，

每次只能有一个线程持有锁，比如前面给大家演示的ReentrantLock就是 以独占方式实现的互斥锁

共 享 锁 ， 允 许 多 个 线 程 同 时 获 取 锁 ， 并 发 访 问 共 享 资 源 ， 比 如 ReentrantReadWriteLock

AQS 的内部实现
AQS 队列内部维护的是一个 FIFO 的双向链表，这种结构的特点是每个数据结构都有两个指针，分别指向直接的后继节点和直接前驱节点。所以双向链表可以从任 意一个节点开始很方便的访问前驱和后继。每个 Node 其实是由线程封装，当线 程争抢锁失败后会封装成Node加入到ASQ队列中去；当获取锁的线程释放锁以 后，会从队列中唤醒一个阻塞的节点(线程)。

 ReentrantLock 的源码分析
以ReentrantLock作为切入点，来看看在这个场景中是如何使用AQS来实现线程 的同步的
ReentrantLock 的时序图
调用ReentrantLock中的lock()方法，源码的调用过程我使用了时序图来展现。

ReentrantLock.lock()
这个是reentrantLock获取锁的入口 public void lock() {     sync.lock(); }

sync实际上是一个抽象的静态内部类，它继承了AQS来实现重入锁的逻辑，我们前面说过AQS是一个同步队列，它能够实现线程的阻塞以及唤醒，但它并不具备 业务功能，所以在不同的同步场景中，会继承AQS来实现对应场景的功能 Sync有两个具体的实现类，

分别是： NofairSync：表示可以存在抢占锁的功能，也就是说不管当前队列上是否存在其他 线程等待，新线程都有机会抢占锁

FailSync:表示所有线程严格按照FIFO来获取锁

NofairSync.lock（Reentrantlock.lock的具体实现）
以非公平锁为例，来看看lock中的实现

1. 非公平锁和公平锁最大的区别在于，在非公平锁中我抢占锁的逻辑是，不管有 没有线程排队，我先上来cas去抢占一下

2. CAS成功，就表示成功获得了锁

3. CAS失败，调用acquire(1)走锁竞争逻辑

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
state 是 AQS 中的一个属性，它在不同的实现中所表达的含义不一样，对于重入 锁的实现来说，表示一个同步状态。它有两个含义的表示 
1. 当state=0时，表示无锁状态 
2. 当 state>0 时，表示已经有线程获得了锁，也就是 state=1，
但是因为 ReentrantLock允许重入，所以同一个线程多次获得同步锁的时候，state会递增， 比如重入5次，那么state=5。 而在释放锁的时候，
同样需要释放5次直到state=0 其他线程才有资格获得锁 ；

 acquire 是 AQS 中的方法，如果 CAS 操作未能成功，说明 state 已经不为 0，此 时继续acquire(1)操作 ➢ 大家思考一下，acquire方法中的1的参数是用来做什么呢？

这个方法的主要逻辑是

1. 通过tryAcquire尝试获取独占锁，如果成功返回true，失败返回false

2. 如果tryAcquire失败，则会通过addWaiter方法将当前线程封装成Node添加 到AQS队列尾部

3. acquireQueued，将Node作为参数，通过自旋去尝试获取锁。

AQS.accquire 
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

acquire 是 AQS 中的方法，如果 CAS 操作未能成功，说明 state 已经不为 0，此 时继续acquire(1)操作
 ➢ 大家思考一下，acquire方法中的1的参数是用来做什么呢？ 这个方法的主要逻辑是 
1. 通过tryAcquire尝试获取独占锁，如果成功返回true，失败返回false 
2. 如果tryAcquire失败，则会通过addWaiter方法将当前线程封装成Node添加 到AQS队列尾部 
3. acquireQueued，将Node作为参数，通过自旋去尝试获取锁。 

NonfairSync.tryAcquire 
这个方法的作用是尝试获取锁，如果成功返回true，不成功返回false 它是重写 AQS 类中的 tryAcquire 方法，并且大家仔细看一下 AQS 中 tryAcquire 方法的定义，
并没有实现，而是抛出异常。按照一般的思维模式，既然是一个不实 现的模版方法，那应该定义成abstract，让子类来实现呀？大家想想为什么 
protected final boolean tryAcquire(int acquires) {     return nonfairTryAcquire(acquires); } 
ReentrantLock.nofairTryAcquire 
1. 获取当前线程，判断当前的锁的状态 2. 如果state=0表示当前是无锁状态，通过cas更新state状态的值 3. 当前线程是属于重入，则增加重入次数 
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//获取当前执行的线程
    int c = getState();//获取state的值 cas就是更新state的值
    if (c == 0) {//表示无锁状态
        if (compareAndSetState(0, acquires)) {//cas替换state的值，cas成功表示获取锁成功
            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;
}

AQS.addWaiter 
当 tryAcquire 方法获取锁失败以后，则会先调用 addWaiter 将当前线程封装成 Node.  入参 mode 表示当前节点的状态，传递的参数是 Node.EXCLUSIVE，表示独占状 态。意味着重入锁用到了AQS的独占锁功能 
1. 将当前线程封装成Node
 2. 当前链表中的 tail 节点是否为空，如果不为空，则通过 cas 操作把当前线程的 node添加到AQS队列
 3. 如果为空或者cas失败，调用enq将节点添加到AQS队列 

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);//将当前线程封装为Node
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;tail 是 AQS 中表示同比队列队尾的属性，默认 是 null 
    if (pred != null) {//tail 不为空的情况下，说明队列中存在节点
        node.prev = pred;//把当前线程的 Node 的 prev 指向 tail 
        if (compareAndSetTail(pred, node)) {//通过 cas 把 node 加入到 AQS 队列，也就是设置为 tail
            pred.next = node;//设置成功以后，把原 tail 节点的 next 指向当前 node 
            return node;
        }
    }
    enq(node);//tail=null,把 node 添加到同步队列 
    return node;
}

enq 
enq就是通过自旋操作把当前节点加入到队列中

private Node enq(final Node node) {
    for (;;) {通过自旋
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

图解分析 
假设3个线程来争抢锁，那么截止到enq方法运行结束之后，或者调用addwaiter 方法结束后，AQS中的链表结构图 

 AQS.acquireQueued
通过 addWaiter 方法把线程添加到链表后，会接着把 Node 作为参数传递给 acquireQueued方法，去竞争锁

1. 获取当前节点的prev节点

2. 如果prev节点为head节点，那么它就有资格去争抢锁，调用tryAcquire抢占 锁

3. 抢占锁成功以后，把获得锁的节点设置为 head，并且移除原来的初始化 head 节点

4. 如果获得锁失败，则根据waitStatus决定是否需要挂起线程

5. 最后，通过cancelAcquire取消获得锁的操作

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();//获 取当前节点的 prev 节点 
            if (p == head && tryAcquire(arg)) {//如 果是 head 节点，说明有资格去争抢锁 
                setHead(node);//获取锁成功，也就是 ThreadA 已经释放了锁，然后设置 head 为 ThreadB 获得执行权 限
                p.next = null; //  // 把原 head节点从链表中移除
                failed = false;
                return interrupted;
            }
//ThreadA 可能还没释放锁，使得 ThreadB 在执 行 tryAcquire 时会返回 false 
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
NofairSync.tryAcquire 
这个方法在前面分析过，就是通过state的状态来判断是否处于无锁状态，然后在 通过cas进行竞争锁操作。成功表示获得锁，失败表示获得锁失败 
shouldParkAfterFailedAcquire 
如果ThreadA的锁还没有释放的情况下，ThreadB和ThreadC来争抢锁肯定是会 失败，那么失败以后会调用shouldParkAfterFailedAcquire方法 Node 有 5 中状态，
分别是：CANCELLED（1），SIGNAL（-1） 、CONDITION（2）、PROPAGATE(-3)、默认状态(0) ；这个方法的主要作用是，通过 Node 的状态来判断，ThreadA 竞争锁失败以后是 否应该被挂起。 
1. 如果ThreadA的pred节点状态为SIGNAL，那就表示可以放心挂起当前线程 
2. 通过循环扫描链表把CANCELLED状态的节点移除 
3. 修改pred节点的状态为SIGNAL,返回false. 返回false时，也就是不需要挂起，返回true，则需要调用parkAndCheckInterrupt 挂起当前线程 

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;//前置节点的 waitStatus
    if (ws == Node.SIGNAL)//如果前置节点为 SIGNAL，意 味着只需要等待其他前置节点的线程被释放
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
return true;//返回 true，意味着可以直接放心的挂 起了 
    if (ws > 0) {//ws 大于 0，意味着 prev 节点取消了排 队，直接移除这个节点就行 
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
do {
            node.prev = pred = pred.prev;//相当于: pred=pred.prev; node.prev=pred; 
        } while (pred.waitStatus > 0); //这里采用循 环，从双向列表中移除 CANCELLED 的节点   
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//利用 cas 设置 prev 节点的状态为 SIGNAL(1) 
    }
    return false;
}
parkAndCheckInterrupt 
使用LockSupport.park挂起当前线程编程WATING状态 

使用LockSupport.park挂起当前线程编程WATING状态 Thread.interrupted，返回当前线程是否被其他线程触发过中断请求，
也就是 thread.interrupt(); 如果有触发过中断请求，那么这个方法会返回当前的中断标识 true，
并且对中断标识进行复位标识已经响应过了中断请求。如果返回true，意味 着在acquire方法中会执行selfInterrupt()。 
private final boolean parkAndCheckInterrupt() {     LockSupport.park(this);     return Thread.interrupted(); } 
通过acquireQueued方法来竞争锁，如果ThreadA还在执行中没有释放锁的话， 意味着ThreadB和ThreadC只能挂起了。 

 锁的释放流程

如果这个时候ThreadA释放锁了，那么我们来看锁被释放后会产生什么效果
ReentrantLock.unlock
在unlock中，会调用release方法来释放锁

public final boolean release(int arg) {
    if (tryRelease(arg)) {//释放锁成功
        Node h = head;//得到 aqs 中 head 节点 
        if (h != null && h.waitStatus != 0)//如果 head 节点不 为空并且状态！=0.调用 unparkSuccessor(h)唤醒后续节点 
            unparkSuccessor(h);
        return true;
    }
    return false;
}

ReentrantLock.tryRelease 
这个方法可以认为是一个设置锁状态的操作，通过将state状态减掉传入的参数值 （参数是1），如果结果状态为0，就将排它锁的Owner设置为null，
以使得其它的线程有机会进行执行。 在排它锁中，加锁的时候状态会增加 1（当然可以自己修改这个值），在解锁的时 候减掉1，同一个锁，在可以重入后，
可能会被叠加为2、 3、 4这些值，
只有unlock() 的次数与 lock()的次数对应才会将 Owner 线程设置为空，而且也只有这种情况下 才会返回true。 
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

unparkSuccessor 
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
int ws = node.waitStatus;//获得 head 节点的状态 
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);// 设置 head 节点 状态为 0

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
Node s = node.next;
    if (s == null || s.waitStatus > 0) {//如果下一个节点为 null 或者 status>0 表示 cancelled 状态. //通过从尾部节点开始扫描，找到距离 head 最近的一个 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); //next 节点不为空，直接唤醒这个线程即可 
}
原本挂起的线程继续执行 
通过ReentrantLock.unlock，原本挂起的线程被唤醒以后继续执行，应该从哪里执 行大家还有印象吧。 原来被挂起的线程是在 acquireQueued 方法中，所以被唤 醒以后继续从这个方法开始执行 
AQS.acquireQueued 
这个方法前面已经完整分析过了，我们只关注一下 ThreadB 被唤醒以后的执行流 程。 由于ThreadB的prev节点指向的是head，并且ThreadA已经释放了锁。所以这 个时候调用tryAcquire方法时，可以顺利获取到锁 
1. 把ThreadB节点当成head 2. 把原head节点的next节点指向为null 

公平锁和非公平锁的区别
锁的公平性是相对于获取锁的顺序而言的，如果是一个公平锁，那么锁的获取顺序 就应该符合请求的绝对时间顺序，也就是 FIFO。 在上面分析的例子来说，只要 CAS 设置同步状态成功，则表示当前线程获取了锁，而公平锁则不一样，差异点 有两个
FairSync.tryAcquire
final void lock() {
    acquire(1);
} 非公平锁在获取锁的时候，会先通过CAS进行抢占，而公平锁则不会
FairSync.tryAcquire
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;
} 这个方法与 nonfair.TryAcquire(int acquires)比较，不同的地方在于判断条件多了 hasQueuedPredecessors()方法，也就是加入了[同步队列中当前节点是否有前驱节点]的判断，如果该方法返回true，则表示有线程比当前线程更早地请求获取锁， 因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

这个方法的主要作用是，通过 Node 的状态来判断，ThreadA 竞争锁失败以后是 否应该被挂起。 1. 如果ThreadA的pred节点状态为SIGNAL，那就表示可以放心挂起当前线程 2. 通过循环扫描链表把CANCELLED状态的节点移除 3. 修改pred节点的状态为SIGNAL,返回false. 返回false时，也就是不需要挂起，返回true，则需要调用parkAndCheckInterrupt 挂起当前线程