JUC并发：AQS源码详细解析

LockSupport原理

是什么：线程等待唤醒机制(wait/notify)的升级加强版；

LockSupport当中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程；

Synchronized,Lock和LockSupport对比

	Synchronized	Lock的Condition	LockSupport
等待	wait()	await()	park()
唤醒	notify()	signal()	unpark(Thread thread)

wait,notify和await,signal的限制：

1、Object类中的wait,notify,notifyAll用于线程唤醒的方法，都必须在Synchronized内部执行，否则会报异常java.lang.IllegalMonitorStateException,必须在锁块中；

2、将notify放在wait方法前面，程序无法执行，线程无法被唤醒；必须先等待再唤醒，线程才能够被唤醒

LockSupport原理：

LockSupport类无锁块要求，之前错误的先唤醒后等待，LockSupport照样支持

LockSupport类使用了一种名为Permit(许可)的概念来做阻塞和唤醒的功能，每个线程都有一个许可permit，permit只有1和0两个值，默认是0；可以把permit许可看成是一种（0，1）信号量（Semaphore）,但与Semaphore不同的是，许可累加的上限是1；

permit默认是0，所以一开始调用park()方法时，当前线程会阻塞，知道别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit在此设置为0并返回。

重点：

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语；LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根到底，LockSupport调用的Unsafe中的Native代码；

LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程；

LockSupport和每个使用它的线程都有一个许可（permit）关联，permit相当于1，0的开关，默认是0；

调用一次unpark就会+1变成1；

调用一次park会消费permit，也就是将1变成0，同时park立即返回；

如果再次调用park会变成阻塞（因为permit=0了会阻塞在这里，直到permit变成1），这时调用unpark会把permit置为1；

每个线程都有一个相关的permit，permit最多只有一个，重复调用unpark也不会积累凭证；

当调用park方法时：

• 如果有凭证，则会直接消耗掉这个凭证然后正常退出；

• 如果无凭证，就必须阻塞等待凭证可用；

而unpark则相反：

• 它会增加一个凭证，但凭证最多只能有一个，累加无效；

面试题

1、为什么可以先唤醒线程后阻塞线程？

因为unpark获得一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞；

2、为什么唤醒两次后阻塞两次，但最终结果还是会阻塞线程？

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次park却需要消费两个凭证，证不够，不能放行；

AQS原理

AQS一般指的是：AbstractQueuedSynchronizer抽象的队列同步器，是JUC中最重要的基石；

技术解释：是用来构建锁或者其他同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类型变量表示锁的持有状态；CLH队列是一个单向链表，AQS中的队列是CLH变体的虚拟双向队列FIFO->先进先出；

锁与同步器的关系：

• 锁面向锁的使用者，即用户层面的API，隐藏了实现细节，调用即可；

• 同步器面向锁的实现者，提出统一规范并简化了锁的实现，屏蔽了同步状态管理、阻塞线程排队和通知、唤醒机制；

ReentrantLock底层的公平锁与非公平锁继承Sync，而Sync又继承自AQS，所以JUC的基石底层都是AQS

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
    }
    static final class NonfairSync extends Sync {/****/ }
    static final class FairSync extends Sync {/****/ }
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
}

原理：

抢到资源的线程直接使用处理业务逻辑，抢不到资源的必然涉及一种排队等候机制。抢占资源失败的线程继续去等待（类似银行业务办理窗口都满了，暂时没有受理窗口的顾客只能去候客区排队等候），但是等候线程任然保留获取锁的可能且获取锁流程仍在继续（候客区的顾客也在等着叫号，轮到了再去受理窗口办理业务）；

如果共享资源被占用，就需要一定的阻塞等待唤醒机制来保证锁的分配。这个机制只要用的是CLH队列的变体实现的。将暂时获取不到锁的线程加入到队列中，这个对列就是AQS的抽象表现。它将请求共享资源的线程封装成队列的节点（Node），通过CAS、自旋以及LockSupport.park()的方式，维护state变量的状态，使并发达到同步的控制效果。

有阻塞就需要排队，需要排队必然需要队列：

AQS使用一个volatile的int类型的成员变量来表示同步状态，通过内置的FIFO队列来完成资源获取的排队工作，将每条要去抢占资源的线程封装成一个Node节点来实现锁的分配，通过CAS完成对State值的修改；

HashMap里面的<k,v>键值对也是封装成Node节点的

AQS内部体系架构源码分析：

AQS=state变量+CLD变种的双端队列(头指针+尾指针)；

队列中包含Node,Node=waitStaus+前后指针指向

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    private static final long serialVersionUID = 7373984972572414691L;
    protected AbstractQueuedSynchronizer() { }
    /**尾部入队，头部出队，CLH队列，是一个双向队列，通过自旋等待
            +------+  prev  +-----+     +-----+
         head |     | <---- |    | <---- |    |  tail
            +------+      +-----+      +-----+
    */
    //静态内部类
    static final class Node {
        //共享,sharde
        static final Node SHARED = new Node();
        //独占,exclusive
        static final Node EXCLUSIVE = null;
        //表示线程获取锁的请求已经被取消,cancelled，
        static final int CANCELLED = 1;
        //后继线程需要唤醒,signal，表示线程已经准备好了，就等资源释放
        static final int SIGNAL = -1;
        //表示节点在等待队列中，节点线程等待condition唤醒,condition
        static final int CONDITION = -2;
        //表示线程处在SHARED情况下，该字段才会被使用，propagate
        static final int PROPAGATE = -3;
        volatile int waitStatus;//等待状态,初始为0，状态是上面几种
        volatile Node prev;//前驱指针
        volatile Node next;//后继指针
        Node nextWaiter;//返回下一个处于CONDITION状态的节点
        volatile Thread thread;//表示处于该节点的线程
        //返回前驱节点，没有的话就抛出空指针异常
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
    }
    private transient volatile Node head;//双端队列头指针
    private transient volatile Node tail;//双端队列尾指针
	 //使用一个volatile的int类型的成员变量来表示同步状态;=0自由状态，>=1有人占用，等待
    private volatile int state;
}

AQS源码深度解读

1、公平与非公平锁的tryAcquire()试图获取锁的方法的区别：

可以明显看出公平锁与非公平锁的lock方法唯一的区别就是公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()是公平锁加锁时判断等待队列中是否存在有效节点的方法。

公平锁：讲究先来后到，线程获取锁时，如果这个锁的等待队列中已经有线程在等待，那么当前线程就会进入等待队列中；

非公平锁：不管是否有等待队列，如果可以获取锁，则立即占有锁对象，也就是说队列的第一个排队线程在unpark()，之后还是需要竞争锁（存在线程竞争的情况下）

//公平锁
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //二者唯一的不同：hasQueuedPredecessors()
        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;
}
//非公平锁
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();//获取state值，判断资源是否有线程占用
    //如果刚好资源不被占用了，state=0,则当前线程占用资源
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            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;
}
//唯一区别的地方：判断了是否需要排队
public final boolean hasQueuedPredecessors() {
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

lock方法：在创建完公平锁和非公平锁后，调用lock方法会进行加锁，最终都会调用acquire方法；

public class ReentrantLock {
    private final Sync sync;
    public void lock() {
        sync.lock();
    }
}
static final class FairSync extends Sync {
    final void lock() {
        acquire(1);
    }
}
static final class NonfairSync extends Sync {
    final void lock() {
        //CAS方法设置state的值，期望是0也就是无人占用，然后更新为1
        if (compareAndSetState(0, 1))
            //state值更新成功后，将占用资源的唯一线程设为当前线程
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //如果state!=0,说明资源被占用，走acquire方法去候客区排队
            acquire(1);
    }
}
//调用lock方法会进行加锁，最终都会调用acquire方法；
//如果线程被占用tryAcquire(arg)==false
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
//非公平锁设置state值的方法，底层是Unsafe类的CAS方法
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

候客区排队等候，入队操作

面试题：A抢占资源，B入队去等候，但是等候队列里面的第一个节点不是B，而是一个默认构造函数构造的虚节点(哨兵节点)，其实并不存储任何信息，只是占位，所以真正的第一个有数据的节点，是从第二个节点开始的；

//模式mode=Node.EXCLUSIVE
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)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);//入队
    return node;
}
//入队
private Node enq(final Node node) {
    //自旋while(true){}
    for (;;) {
        Node t = tail;//尾节点
        //一开始，队列为空，所以t=tail=null，需要初始化
        //初始化时新建一个默认参数的Node(Thread=null,waitStatus=0)作为哨兵节点，并设置为head
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //第二次循环时才真正将node入队列,并将node设为尾节点
            //哨兵节点t<-node
            //哨兵节点t->node
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;//返回t,退出自旋循环
            }
        }
    }
}
//CAS操作设置头尾节点
private final boolean compareAndSetHead(Node update) {
    return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
private final boolean compareAndSetTail(Node expect, Node update) {
    return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

对于入了队的节点进行再次抢占资源，如果再次失败就会执行park()挂起阻塞，等待被唤醒

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        //自旋
        for (;;) {
            //获取node的前驱节点
            final Node p = node.predecessor();
            //再次试图抢占锁
            if (p == head && tryAcquire(arg)) {
                setHead(node); //设置当前节点为头节点
                // help GC 会由GC进行回收,因为p节点后继指针为null，且也没有指针指向p
                p.next = null; 
                failed = false;
                return interrupted;
            }
            //将等待队列里的线程执行park()挂起阻塞,等待唤醒
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
//A离开，B上位，则哨兵节点被GC回收，B节点变成新的哨兵节点要占位
private void setHead(Node node) {
    head = node;//将B节点设为队列头节点
    node.thread = null;//B节点的线程设为null
    node.prev = null;//B节点的前去指针设为null
}

final Node predecessor() throws NullPointerException {
    Node p = prev;
    if (p == null)
        throw new NullPointerException();
    else
        return p;
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;//如果是哨兵节点，则status=0
    //如果是SIGNAL状态，即等待被占用的资源释放，直接返回true
    //准备继续调用parkAndCheckInterrupt()
    if (ws == Node.SIGNAL)
        return true;
    //ws>0说明是CANCELLED状态
    if (ws > 0) {
        //循环判断前驱节点的前驱节点是否也为CANCELLED状态，忽略该状态的节点，重新连接队列
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //以上条件都不满足，则设置哨兵节点的status=-1,下次自旋返回true，用于后继唤醒
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
//将等待队列里的线程执行park()挂起阻塞,等待唤醒，此处会一直阻塞，直至唤醒
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    //根据park的API描述，程序在下属三种情况下会继续向下执行
    //1、被unpark;2、被中断(interrupt);3、其他不合逻辑的返回才会继续向下执行
    //因上述三种情况执行至此，返回当前线程的中断状态，并清空中断状态
    //如果由于被中断，该方法会返回true
    return Thread.interrupted();
}

unlock()方法

public void unlock() {
    sync.release(1);
}
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;//头指针
        //头指针，也就是哨兵节点!=null，且waitStatus=-1,满足if条件
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;//1-1=0
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        //将占有资源的线程设为null，表示没有线程占用该资源
        setExclusiveOwnerThread(null);
    }
    setState(c);//设置status=0
    return free;//true
}
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    //哨兵节点的waitStatus=-1,满足条件
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);//又把waitStatus设为0
    //下一个节点
    Node s = node.next;
    //如果节点为null或是cancelled状态的，则忽略，往后寻找真正的需要被唤醒的节点
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    //如果不为空，就调用unpark将其唤醒
    if (s != null)
        LockSupport.unpark(s.thread);
}

文章完，希望我的文章能够给大家一些技术上的帮助！！