ReentrantLock加锁和释放锁底层源码分析

ReentranLock 和 AQS源码分析（第一次写博客，见谅，直接将源码每一行注释写上，更清晰）

ReentranLock为可重入锁：指为同一个线程可以重复进入被锁定的资源

ReentranLock：分为公平锁和非公平锁 （默认非公平锁）
公平锁：所有的线程有序的排队 Lock lock = new ReentranLock(true);
非公平锁：线程阻塞时，先尝试获取锁，没有获得再进行排队等待 Lock lock = new ReentranLock();

源码类图：

ReentranLock 主要构成：

// 静态内部类
private final Sync sync;

/**
 * Base of synchronization control for this lock. Subclassed
 * into fair and nonfair versions below. Uses AQS state to
 * represent the number of holds on the lock.
 */
 // 静态内部内，继承了abs，AbstractQueuedSynchronizer ：抽象的队列同步器
 // 是所有的JUC并发包的基石，
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;

AbstractQueuedSynchronizer ：抽象的队列同步器，是所有的JUC并发包的基石，是实现同步锁和线程同步类组件的基础框架

AbstractQueuedSynchronizer ： 的源码构成 ，实现同步的主要成员：一个Node双向队列（CLD对列），一个volatile int 类型state的锁定标志

/**
 * The synchronization state.
 */
 // 此状态默认为 0，代表资源没有被锁定，当一个线程获得锁的时候 变为 1，代表锁已经被获得，其他线程需要等待阻塞
 // 当state超过1，代表一个线程重入这个锁，所以 lock的次数和unLock的次数需要一致
private volatile int state;

// Node头节点
private transient volatile Node head;

// Node 尾结点
private transient volatile Node tail;

AbstractQueuedSynchronizer 内部内 Node：

static final class Node {
    /** Marker to indicate a node is waiting in shared mode */
    static final Node SHARED = new Node();
    /** Marker to indicate a node is waiting in exclusive mode */
    static final Node EXCLUSIVE = null;

    /** waitStatus value to indicate thread has cancelled */
    static final int CANCELLED =  1;
    /** waitStatus value to indicate successor's thread needs unparking */
    static final int SIGNAL    = -1;
    /** waitStatus value to indicate thread is waiting on condition */
    static final int CONDITION = -2;
    /**
     * waitStatus value to indicate the next acquireShared should
     * unconditionally propagate
     */
    static final int PROPAGATE = -3;
    // 等待状态 （值为上面的状态值）
    volatile int waitStatus;
    // 前一个节点
    volatile Node prev;
   // 后节点
    volatile Node next;

   // 线程
    volatile Thread thread;
    Node nextWaiter;

    /**
     * Returns true if node is waiting in shared mode.
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

     * @return the predecessor of this node
     */
     // 获取 前一个节点
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }
    Node() {    // Used to establish initial head or SHARED marker
    }
    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
    }

    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

ReentranLock 非公平锁加锁源码分析：

// 对锁的操作，基本都是对sync操作的封装
public void lock() {
    sync.lock();
}

ReentrenLock 内部内 NonfairSync 非公平锁 lock方法

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
     // 
    final void lock() {
        // 非公平锁加锁首先会尝试获取锁，对父类 AbstractQueuedSynchronizer  中的state 进行CAS，将 0（无锁状态） 改为 1（加锁状态） 
        if (compareAndSetState(0, 1))
        // 成功 获取锁，设置AbstractQueuedSynchronizer   的父类AbstractOwnableSynchronizer  的 private transient Thread exclusiveOwnerThread;
        // 为当前线程，意思为可执行线程
            setExclusiveOwnerThread(Thread.currentThread());
        else
        // 失败
            acquire(1);
    }

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

NonfairSync 中的 acquire(1);进入 AbstractQueuedSynchronizer 的 acquire(1) 方法

public final void acquire(int arg) {
    // !tryAcquire(arg) 此方法是首先判断获取锁的线程时候正好离开，尝试再获取锁，然后判断获取到的锁是否就是当前线程，如果是当前线程，就可重入，不然返回true
    // addWaiter(Node.EXCLUSIVE) 将当前线程加入等待队列
    if (!tryAcquire(arg) &&
      // acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 将当前线程 使用 LockSupport.park挂起
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 讲当前线程 设置为 中断标志，中断标志不代表停止当前线程
        selfInterrupt();
}

tryAcquire(arg) ：

// AbstractQueuedSynchronizer    父类方法，落地实现在子类中 即ReentrenLock  
// AbstractQueuedSynchronizer    类
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

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

// nonfairTryAcquire(acquires);
// 参数 为 1
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 获取 AbstractQueuedSynchronizer     state 状态，无锁为 0 加锁 为 1
    int c = getState();
    if (c == 0) {
        // 可能占用资源的线程正好释放锁，然后当前线程尝试获取锁
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 锁被占用，判断占用锁的线程是否就是当前线程，如果是当前线程，代表获取锁为可重入锁，意思就是同一个线程多次加锁
    else if (current == getExclusiveOwnerThread()) {
        // AbstractQueuedSynchronizer      的 锁的状态 state  加一，
        // 所以，一个线程 lock几次，就必须unlock几次，保证 最后释放锁的时候 state为0
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
            //将线程重入获得锁的次数 记录到 state中，方便后面unlock进行解锁
        setState(nextc);
        return true;
    }
    // 获取锁失败，也不是重入线程
    return false;
}

addWaiter(Node.EXCLUSIVE) 方法 Node.EXCLUSIVE 为null
Node双向队列 的 头节点为 哨兵节点，新的线程加入队列实际为 从第二个节点加入

// AbstractQueuedSynchronizer 类   
private Node addWaiter(Node mode) {
    // 根据当前线程，创建一个Node节点
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    // 获取尾节点 Node
    Node pred = tail;
    // 如果尾节点 不为null，则代表 队列不需要初始化
    if (pred != null) {
        // 设置新添的Node节点的前一个节点为尾结点
        node.prev = pred;
        // 通过CAS 将尾结点设置为 当前节点
        if (compareAndSetTail(pred, node)) {
             // 将原来的尾结点 的下一个节点设置为 新节点 也就是 新的尾结点
            pred.next = node;
            return node;
        }
    }
    // 尾结点为 null ，初始化 队列
    enq(node);
    return node;
}

// AbstractQueuedSynchronizer 类 的 enq(node);方法
private Node enq(final Node node) {
    // 自旋
    for (;;) {
        //  第一次自旋 ：获取尾结点，第一次自旋，尾结点为 null
        // 第二次自旋： 尾结点不为 null，为一个空的node对象,并且和头节点对象相同，这个空node节点的 waitStatus 的值为默认的 0
        Node t = tail;
        // 第一次自旋:  如果 尾结点为 null,需要初始化 Node 队列
        if (t == null) { // Must initialize
            // 第一次自旋: 通过CAS将 空的节点设置为头节点 ，头节点为哨兵节点，所以线程加入队列，实际为从第二个节点加入
            if (compareAndSetHead(new Node()))
                // 第一次自旋: 尾结点也设置为空节点，和头节点为同一个空对象，进行第二次自旋
                tail = head;
        } else {
            // 第二次自旋： 将空的尾节点（也是头结点）设置为 新节点的 上一个节点
            node.prev = t;
            // 通过CAS 将新节点设置 为 尾结点
            if (compareAndSetTail(t, node)) {
                // 将 空节点（头结点） 的下一个节点 设置为新节点
                t.next = node;
                return t;
            }
        }
    }
}

acquireQueued(Node node, arg) // 此方法的主要目的为 ：讲新加入线程队列的线程使用LockSupport.park()，阻塞线程

// arg 为 1   来阻塞线程
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        // 线程是否被标记为中断
        boolean interrupted = false;
        // 自旋
        for (;;) {
            // 获取新节点的 前一个节点
            final Node p = node.predecessor();
            // 如果前一个节点为头结点 并且再次尝试获取锁成功
             // 当获取锁的线程释放锁了之后，只能是头结点之后的节点CAS获取锁，最后从这个逻辑分支出去
            // 因为是自旋，所以，所有的列队中的阻塞线程最后都会进入这个if中
            if (p == head && tryAcquire(arg)) {
         
                // 讲新节点设置为头结点,并且将这个node对象 的 thread 和 prev 设置为null，变成一个空的 node节点，起一个哨兵作用
                // private void setHead(Node node) {
                //    head = node;
                //    node.thread = null;
                 //   node.prev = null;
                //}
                setHead(node);
                // 讲头结点的下一个节点设置为null,这样这个节点就不引用其他对象，也不被其他对象引用，方便GC回收
                p.next = null; // help GC
                // 阻塞线程失败
                failed = false;
                // 返回false
                return interrupted;
            }
            // 第一次自旋：如果前一个节点不是头节点，或者获取锁失败，将前一个node节点的waitStatus设置为 -1， shouldParkAfterFailedAcquire(p, node)返回 false
            // 第二次自旋： shouldParkAfterFailedAcquire(p, node)返回ture， parkAndCheckInterrupt()，将线程阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// shouldParkAfterFailedAcquire(p, node)
// 将前一个线程node节点的waitStatus 设置为 -1
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获得 前一个节点的 waitStatus
    int ws = pred.waitStatus;
    // waitStatus == -1
    if (ws == Node.SIGNAL)
        
        return true;
    if (ws > 0) {
      
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
          // 通过CAS 将前一个节点的 waitStatus 设置为 -1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

// parkAndCheckInterrupt();线程阻塞的地方
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    // 如果某个线程调用 LockSupport.unpark(),则放行
    return Thread.interrupted();
}

Unlock源码分析

// 依然调用sync内部内的方法 release（1）
public void unlock() {
    sync.release(1);
}

// AbstractQueuedSynchronizer 类中的方法
public final boolean release(int arg) {
    // 尝试释放当前线程的锁
    if (tryRelease(arg)) {
        // 释放成功
        Node h = head;
        if (h != null && h.waitStatus != 0)
            // 通过头节点来通知队列中第二个节点的线程 LockSupport.unpark()，唤醒此线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// ReentrenLock   tryRelease(arg)
protected final boolean tryRelease(int releases) {
    // 获得锁 state的状态 0 为无锁，>1 为有锁，
    int c = getState() - releases;
    // 如果当前线程不是获得锁的线程，异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果释放了一次锁之后，锁的状态为 0 ；无锁
    // 如果同意线程重入了多次锁，必须进行多次的释放锁，因此这里每释放一次锁，锁的状态 -1，直到当前线程释放锁的次数和 state的数值一样，state为 0 才可以完全释放锁
    if (c == 0) {
        free = true;
        // 将执行线程设定为 null,供其他抢到锁的线程来占用
        setExclusiveOwnerThread(null);
    }
    // 设置 锁的状态
    // 0 代表完全释放锁，>0表示当前线程进行了多次重入锁，需要对应次数的释放锁，本次只代表释放一次锁
    setState(c);
    return free;
}


 // AbstractQueuedSynchronizer   unparkSuccessor(h);
 // node 参数为 队列中 头节点
 private void unparkSuccessor(Node node) {
    // 获取头节点的 waitStatus ，在线程加入等待队列的时候，已经将 头节点的 waitStatus 通过自旋的方式设置为了 -1
    int ws = node.waitStatus;
    if (ws < 0)
        // 设置 头节点的  waitStatus 为 0，这里是因为在第二个节点抢到锁之后，会将第二个节点设置为头节点，原来的旧的头节点node会设置为空，方便回收
        compareAndSetWaitStatus(node, ws, 0);
    // 获取第二个节点    
    Node s = node.next;
    // 如果第二个节点为空，或者他的状态 >0
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 遍历等待队列，从后到前
        for (Node t = tail; t != null && t != node; t = t.prev)
        // 如果哪个队列的 waitStatus <= 0,<0代表这个node不为tail节点，=0代表这个节点为尾结点  
            if (t.waitStatus <= 0)
                //s 为去抢锁的节点
                s = t;
    }
    if (s != null)
        // 唤醒第二个节点中的线程，进行抢锁
        LockSupport.unpark(s.thread);
}