源码解读--AbstractQueuedSynchronizer讲解之Reentrantlock实现

一.锁

  说起AbstractQueuedSynchronizer（传说中的AQS)，可能有些同学不知道，但是说到ReentrantLock,CountDownLatch,Seamphore，大家可能用用过吧。他们都是用锁来实现了，而锁里面又分独占锁和分享锁。具体锁的种类请看文章。ReentrantLock是独占锁，而CountDownLatch,Seamphore是分享锁。锁里面还有一个重要的分类：公平锁和非公平锁。java源码系列。

公平锁：线程一个一个排队，确保先来的那个等待的线程最早执行。

非公平锁：不能保证先来的那个等待的线程最早执行。

二.AQS

AQS是一个抽象类，经常被使用的是它的子类Sync，会具体实现AQS里面一些方法。AQS里面主要有三个变量。

private transient volatile Node head;  //队列头结点
private transient volatile Node tail;  //队列尾
private volatile int state;  //同步的状态

用了一个双向的链表来存储当前线程信息。大致示意图如下

原理介绍:

以ReentrantLock为例，他的初始状态state=0，当有线程获取锁的时候，state加1，接着后面还有线程过来获取这个锁，就需要在等待队列里面等待。如果之前的线程释放锁，那么后面等待队列里面的线程就可以获取到锁，执行任务。如果期间有中断，这个线程也会被终止掉。

三.源码实现

这里主要介绍以ReentrantLock为基础介绍AQS。

3.1 ReentrantLock锁初始化

public ReentrantLock() {  //默认是new一个非公平的锁，线程之间需要按顺序排队，效率会高一点
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {  //通过true和false来指定是否创建一个公平锁
    sync = fair ? new FairSync() : new NonfairSync();
}

3.2ReentrantLock 获取锁

public void lock() {  //获取锁
    sync.lock();  //默认用的是非公平锁，那我们就先来看看非公平锁的实现
}

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(); //如果线程在阻塞的过程中发生了中断，自身线程也需要中断
}

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

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();  //获取当前线程
    int c = getState();  //获取同步状态
    if (c == 0) {  //如果锁获取资源
        if (compareAndSetState(0, acquires)) { //设置资源的状态
            setExclusiveOwnerThread(current);  //将当前线程设置为独占模式
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {  //检查当前线程是独占模式，如果成立的话,这里可以是线程重入
        int nextc = c + acquires;   //资源增加acquires个
        if (nextc < 0) // 资源添加的超出int的范围，抛出越界异常
            throw new Error("Maximum lock count exceeded");
        setState(nextc);  //设置资源的状态
        return true;
    }
    return false;
}

private Node addWaiter(Node mode) {  //线程没有获取到资源，就需要放到同步队列里面
    Node node = new Node(Thread.currentThread(), mode);  //由当前线程和独占模式创建一个节点
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {  //如果队列不是空
        node.prev = pred;
        if (compareAndSetTail(pred, node)) { //就将这个node节点添加到队列的尾部
            pred.next = node;
            return node;
        }
    }
    enq(node);  //如果队列为空，就需要初始化这个队列，并将这个ndoe放到队列的尾部
    return node;
}

private Node enq(final Node node) {  //初始队列，并且将node节点入队列
    for (;;) {  //死循环（自旋）
        Node t = tail;
        if (t == null) { // 如果节点为空，就初始化一个空的节点当做队头和队尾
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {  //之前if执行完了，队列里面有了一个空的数据
            node.prev = t;  //t就是那个之前添加的空的节点
            if (compareAndSetTail(t, node)) { //将node放到队尾
                t.next = node;
                return t;  //for 循环唯一的出口
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {  //获取队列资源，这里面会将获取不到资源的线程阻塞，当有资源可以获取的时候，它会接着执行，但是注意返回的中断的状态
    boolean failed = true; //结果是否是失败
    try {
        boolean interrupted = false;  //是否发生了中断
        for (;;) {
            final Node p = node.predecessor();  //找到node的前驱节点
            if (p == head && tryAcquire(arg)) {  //如果前驱节点是head并且获取资源成功
                setHead(node);  //将node设置为头节点
                p.next = null; //断链，破引用 以便系统GC
                failed = false;  //执行成功了
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&  //ndoe前驱节点不是head，需要返回阻塞的标记
                parkAndCheckInterrupt()) //如果已经返回了阻塞的标记，则阻塞线程，并且如果返回线程中断的状态
                interrupted = true;
        }
    } finally {
        if (failed)  //未知原因，执行失败，则取消获取资源
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)  //如果前驱节点的状态是signal，直接返回true，是线程去阻塞
        return true;
    if (ws > 0) {// 线程是取消状态
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);  //从后往前过滤取消线程，直到第一个线程不是取消的线程为止
        pred.next = node;
    } else {  //如果不是取消状态 我们就需要将前驱节点的状态设置为signal，到下一次执行该方法是，前驱节点就是signal，返回为true
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;  
}

private final boolean parkAndCheckInterrupt() { //中断线程 使用LockSupport.park中断当前线程
    LockSupport.park(this);
    return Thread.interrupted();  //返回的是线程的中断状态，可能这个线程在阻塞的过程中发生过中断
}

小结：到此获取锁已经讲完了。

1.线程先去获取锁，如果可以获取锁，直接返回。

2.如果线程不能获取到锁，就会添加到阻塞队列中，如果队列为空，还需要初始化队列。

3.在线程阻塞的过程中，可能会发生中断，最后可能还需要中断处理一下。

3.3ReentrantLock 释放锁

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

public final boolean release(int arg) {
    if (tryRelease(arg)) {  //是否可以释放资源
        Node h = head;
        if (h != null && h.waitStatus != 0) //如果队列头节点不为null并且它的状态不是0
            unparkSuccessor(h);  //唤醒后继节点
        return true;
    }
    return false;
}

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); //将独占式的线程设置为null
    }
    setState(c); //设置资源的状态
    return free;
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)  //如果线程没有被取消，设置前驱node节点的的状态是0
        compareAndSetWaitStatus(node, ws, 0);
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {//如果后继节点是null或者节点是取消状态
        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); //唤醒后继节点
}

小结：到此释放锁已经讲完了。

1.先去看线程能不能获取到释放资源的能力

2.如果可以的话就跳过那些已经取消了的线程（是头节点的后继节点里面的线程）唤醒。

四.总结

本文RentrantLock为骨，讲解了非公平锁的实现，借助了底层了AQS,下面来总结一下大致的流程：

初始状态state=0，当有线程获取锁的时候，state加1，接着后面还有线程过来获取这个锁，就需要在等待队列里面等待。同步队列里面头结点获取资源后，会唤醒后继节点去获取锁，当他获取到锁就会执行自己的任务。如果期间有中断，这个线程也会被终止掉。