AQS原理解析

AQS（AbstractQueueSynchronizer) 即抽象队列同步器, 听起来非常拗口，没有关系，暂且先记住队列、同步这两个关键字，需要把它理解为一个框架，即用来实现多线程访问共享资源的同步框架。比如ReentrantLock、Semaphore、CountDownLatch等等的实现都依赖于这个同步框架。

AQS的原理是CLH锁的一个变种，根据某大佬的博客讲解，一般的自旋锁会将并发所有的竞争集中在一个标志位当中，而CLH锁的思想是将竞争资源的线程排成一个队列，每个后进来的线程仅在前一个标志位上进行自旋，当头节点释放锁后，后继线程会在自旋时发现这个变化，从而尝试获取锁来进入资源临界区。通过这种设计来最大化的减少CPU缓存的失效次数，如果是普通的自旋锁，每次标志位变化都会引起所有的CPU缓存失效然后去内存当中重新读取相应的值，通过CLH锁，将这个粒度缩小到了单个CPU范围内。

本文试图从ReentrantLock的实现来完成对AQS原理的分析来方便理解和阅读。

在讲可重入锁之前这里顺带给一个不可重入锁的实现demo;

public class UnreentrantLock {

    private AtomicReference<Thread> owner = new AtomicReference<Thread>();

    public void lock() {
        Thread current = Thread.currentThread();
        //这句是很经典的“自旋”语法，笔者发现了大量在下面owner前加了个！的代码博客， 很显然代码都没运行过甚至没有看懂就写上去了。
        for (;;) {
            if (owner.compareAndSet(null, current)) {
                return;
            }
        }
    }

    public void unlock() {
        Thread current = Thread.currentThread();
        owner.compareAndSet(current, null);
    }
}

记住，任何CAS算法往底层走最终都会跑到UnSafe这个类来调用Native方法，这个demo还是比较好看懂的，通过一个死循环来自旋线程，在同一线程第二次进入该方法时，由于owner的值已经为current了，但是第二次自旋的expect value 仍为null,这样就会导致if语句的判断一直为false从而一直死循环导致后面的unlock()方法没法执行。

进入正题，先看Reen;trantLock的lock方法

 /**       如果state为0设置当前线程为独占(互斥)锁, 否则的话尝试获取锁
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

acquire(1)的源码如下:

/* 先尝试获取锁，  失败后就添加一个独占模式的节点进入CLH队列当中,如果在等待过程中线程被中断过，它不会响应而是在获取资源后再进行自我中断selfInterrupt();*/
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

接下来就得看tryAcquire和acquireQueued、addWaiter的实现了，根据ReentrantLock默认的非公平锁来看源码会一直走到如下代码中

/* 用nextc来计算重入次数， 那么为什么会小于0呢， 在int值大于2147483647后，这个值就会为-2147483648
*/
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;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

再看后面的方法先看addWaiter

/*  如果尾节点不为空那么将新的节点通过cas入队设置成尾节点并返回，否则执行enq方法
*/
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;
    }

查看enq

/*  这里的代码还是比较容易看懂的， 比如说多个线程同时enq, 那么只有一个线程通过CAS
被初始化成tail和head节点，然后另外的线程继续死循环执行else条件的cas操作来进行尾节点替换，
每次cas都会成功一个线程， 根据线程冲突个数来决定循环次数 。
*/
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;
                }
            }
        }
    }

再然后就是acquireQueued方法

/* 先获取当前节点的前驱节点，如果前驱节点为头节点那么再尝试一次获取锁,
成功后把自己设为头节点并把p相关引用置空方便GC，否则的话需要线程需要根据shouldParkAfterFailedAcquire考虑是否将自己阻塞
*/
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

看shouldParkAfterFailedAcquire

/*
判断前驱节点的waitStatus是否为SIGNAL,是则对该线程进行阻塞，如果前驱节点CANCELLED,
则需要进行循环找到第一个不为CANCELLED的节点作为自己的前驱，然后通过上一层方法的死循环
又会再执行一次shouldParkAfterFailedAcquire,这个时候会将前驱节点设置成SIGNAL,
然后又通过上一层方法的死循环，再执行过来此时就可以返回True了， 然后线程阻塞，
然后还是外层死循环会不断判断该节点的前驱节点是否为头节点，一旦为头节点又尝试获取锁
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            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);
        }
        return false;
    }

猜你喜欢