AQS核心组件及其互斥锁的实现原理

一.Node

不了解AQS的请先看这里
加锁过程很重要，请耐心从上往下，跟着我的提示看完，会有不一样的理解。当然也需要深思

java.util.concurrent.locks.AbstractQueuedSynchronizer.Node也就是整个QAS的核心也就是列表的节点。

static final class Node {
        static final Node SHARED = new Node();
        
        static final Node EXCLUSIVE = null;

        static final int CANCELLED =  1;
        
        static final int SIGNAL    = -1;
        
        static final int CONDITION = -2;

        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;
        }

        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;
        }
    }

上面也就是Node的源代码，熟悉数据结构的同学应该很容易理解大部分的属性，比如prev(前驱节点)、next(后继节点)，这里也就不带着大家一起看了。
– Thread：保存线程的引用。

– nextWaiter:下一个阻塞队列，Condition.await()阻塞的队列。

– waitStatus：状态值，也就是控制线程阻塞的核心属性。

值	说明
1(CANCELLED)	也就是当前的线程被中断(也可以说取消)，就是线程无效
-1(SIGNAL)	节点的后继节点被挂起，也就是说有别的线程等待当前的线程释放锁，请看下面源码回头看会更清楚
-2(CONDITION)	通过Condition.await()阻塞的线程，当线程被释放时，状态变为-1，进入阻塞的队列,争抢锁的资源
0	初始化的默认值
-3(PROPAGATE)	共享的这里不涉及

二.通过源码查看上面属性值的作用

请大家打开源码阅读下面文章，我不能把所有的代码都说一遍，只说核心的东西，所以大家需要源代码跟上思路

1.互斥锁的加锁实现(ReentrantLock-NonfairSync(非公平))

NonfairSync也就是非公平队列，是AbstractQueuedSynchronizer的实现类，而AbstractQueuedSynchronizer中封装了Node内部类。就像是电脑的CPU是核心，但是需要显示器键盘操作系统等，才可以让他发挥作用。另外，jdk团队使用模版设计模式。

code1.1

final void lock() {
	// 开始默认值为0，如果CAS成功设置为1，说明开始无线程占用，一个线程成功占用。
	if (compareAndSetState(0, 1))
		// 设置进入的线程为当前线程。
		setExclusiveOwnerThread(Thread.currentThread());
	else
		// 已经被锁的逻辑，向下查看code1.2
		acquire(1);
	}

code1.2

    public final void acquire(int arg) {
    	// tryAcquire：代码直接调用nonfairTryAcquire()，查看code1.3
        if (!tryAcquire(arg) &&
        	// 下面方法的逻辑就是把线程放入等待队列。
        	// code1.4---addWaiter()
        	// code1.5---acquireQueued()
        	// 查看code1.4后查看code1.5
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

code1.3

该方法是实现重入锁的核心代码。查看完毕，返回code1.2

该代码如果是同一个线程进入，state状态值加1。

final boolean nonfairTryAcquire(int acquires) {
			// 获取当前线程
            final Thread current = Thread.currentThread();
            // 获取状态值
            int c = getState();
            // 如果为0，说明，之前的线程退出代码块，可以尝试进入
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
   			// 不为0情况，并且当前线程就是已经拿到锁的线程。
            else if (current == getExclusiveOwnerThread()) {
            	// 状态值加1，标记线程进入的次数。
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            // 如果线程为退出，而且请求的线程不是进入的线程。
            return false;
        }

code1.4

当前的节点封装为node，并放入队列中。此方法的代码作为code1.5的参数。查看完毕，请看code1.5
就算是阻塞的第一个节点，也有一个前驱节点，也就是head，代表已经进入代码块的线程

    private Node addWaiter(Node mode) {
    	// 声明一个node
        Node node = new Node(Thread.currentThread(), mode);
        // 拿到尾节点
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            // 通过cas设置成尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        /*查看code1.6*/
        enq(node);
        return node;
    }

code1.5

查看完毕

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
            	// 获取前驱节点，通过code1.6的操作，前驱节点不可能为空，请大家自己查看node.predecessor().
                final Node p = node.predecessor();
                /*code1.4的解释已经提到，head代表当前的线程，因为p==head所以那么说明不存在前面的节点了，调用这个方法之前，这个要放入等待队列的线程p已经是可以进入加锁的代码快了，tryAcquire尝试进入代码，如果失败，说明这个线程已经执行结束，或者取消，返回false，这里回头看一下code1.3的selfInterrupt方法再回来。*/
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                /*shouldParkAfterFailedAcquire方法把当前线程节点的前驱节点waitstatus值设置为-1，再结合每一个等待线程都有一个前驱节点，更加证明了head节点代表当前正在执行的线程，这里需要结合后边的unlock解锁方法，大家才能懂，因为解锁释放线程的时候是释放head的后继节点*/
                // 同时证明了-1的值是说后面有线程等待当前线程的结束
                if (shouldParkAfterFailedAcquire(p, node) &&
                	// 前面设置成功后，lockSupport阻塞当前线程。。
                	//到这里加锁完毕，恭喜你。
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
            	// 已经取消的线程状态设置为1，但jdk团队考虑的非常周到，大家自行阅读，我有点累了
                cancelAcquire(node);
        }
    }

code1.6

查看完毕，返回code1.4
队列为空的时候(该线程是第一个等待的线程)，或者cas把新的节点设置为尾节点失败的时候进入该方法，该方法作用是当tail为空的时候初始化队列的头尾节点，并把当前节点设置为尾节点。

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
            /*第一个线程进入，所以通过cas初始化尾节点和头节点是一个默认的node，也就是waitStatus的值为0，为死循环所以只有成功才能走到下面的t!=null的代码块，也就是必须成功。*/
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
            	// 设置新的node为为节点，之前尾节点设置为新node的前驱节点。
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

2.互斥锁的解锁实现(ReentrantLock-NonfairSync(非公平))

开始就是调用一个方法sync.release()。

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

code2.1

    public final boolean release(int arg) {
    	// 解锁，返回true证明可以让别的线程进入，false表示重入了多个，只解锁了部分。查看code1.2
        if (tryRelease(arg)) {
        	// 如果已经完成释放，可以让等待队列中的线程进入，结合之前所讲的，head表示当前线程，值为-1则表示有线程等待。
            Node h = head;
            if (h != null && h.waitStatus != 0)
            	// 释放等待的线程 查看code2.3
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

code2.2

解锁过程，每次给state减1，当state为0，则全部退出，可以让别的线程进入，查看完毕，返回code2.1

       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;
        }

code2.3

   private void unparkSuccessor(Node node) {

        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
		// 释放的是后面的节点
        Node s = node.next;
        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;
        }
        if (s != null)
        	// 释放选中的线程
            LockSupport.unpark(s.thread);
    }

总结

这里介绍了等待队列，还有jdk实现的Condition可以完成挂起和释放的队列，有兴趣的大家自行查看。