Java中的AbstractQueuedSynchronizer队列同步器

AbstractQueuedSynchronizer队列同步器

队列同步器的概念

​ 队列同步器是用来构建其他锁组件的基础框架。它使用了一个int state表示同步状态，使用了一个先进先出的队列来完成资源获取线程的排队工作。

​ 同步器的主要使用方式是继承，子类通过继承AQS并且实现它的抽象方法来管理同步状态。通过getState()、setState(int newState)、compareAndSetState(int oldState,int newState)来更改同步状态。这些同步状态都是原子操作。

​ 同步器本身并没有实现任何同步接口，它只是定义了若干同步状态获取和释放的方法来供自定义同步组件使用。

​ 它既可以实现独占地获取同步状态，也可以共享的获取同步状态。这样就可以方便的实现不同的同步组件（ReentrantLock、ReentrantReadWriteLock和CountDownLatch等）.

​ 锁是面向使用者的，它定义了使用者与锁交互的接口，隐藏了实现细节；同步器面向的是锁的是闲着，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。锁和同步器很好地隔离了使用者和实现者所需关注的领域。

###7.2.2 队列同步器的接口与示例

在使用同步器实现锁时，提供了以下几个方法来获取和改变同步状态：

• getState()： 获取当前同步状态。
• setState(int newState): 将当前同步状态设置为新的状态
• compareAndSetState(int old, int new): 使用CAS操作来更改锁的状态，保证状态设置的原子性。

这个state是被volatile修饰的，AQS使用了volatile和CAS操作来保证状态修改的原子性。

队列同步器提供了以下几个类似抽象方法，供锁的实现者来重写。

实现自定义锁时，可以使用同步器提供的模板方法：

同步器提供的方法分为三类：

• 独占式的获取和释放同步状态
• 共享式的获取和释放同步状态
• 查询同步队列等待的线程

下面使用了一个自定义独占锁：

public class AqsTest implements Lock{
    private Sync sync;
    public AqsTest() {
        this.sync = new Sync();
    }
    static class Sync extends AbstractQueuedSynchronizer {

        // 首先判断锁的状态是否为0，如果是，就使用CAS获取锁，获取失败返回false
        @Override
        protected boolean tryAcquire(int state) {
            if (compareAndSetState(0, state)) {
                // 设置当前获得锁的线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 释放锁,将锁状态置为0
        @Override
        protected boolean tryRelease(int state) {
            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            }

            setState(0);
            // 清空当前获得锁线程标识
            setExclusiveOwnerThread(null);
            return true;
        }
        
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 0;
        }
        
        Condition newCondition() {
            return new ConditionObject();
        }
    }

    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1,unit.toNanos(time));
    }

    @Override
    public void unlock() {
        sync.tryRelease(0);
    }

    // 是否被锁
    public boolean isLocked() {
        return sync.isHeldExclusively();
    }

    // 是否有等待线程
    public boolean hasWaitThreads() {
        return sync.hasQueuedThreads();
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
}

队列同步实现分析之同步队列

​ 同步器依赖内部维持一个先进先出(FIFO)的双向队列来管理同步状态。当前线程获取同步状态失败后，同步器会把当前线程以及等待状态信息组装成Node，并且将其放到同步队列的尾部，并且会阻塞该线程。当同步状态被释放后，首节点出队，接下来的首节点尝试获得同步状态。

​ 同步队列中的节点Node存储着阻塞线程的引用、前驱节点、后续节点和等待状态。

同步器持有头结点和尾节点的引用head和tail，获取共享状态失败的线程会进入队列的尾部。

---

同步器中包含2个引用，一个指向头结点，一个指向尾节点。当一个线程获得同步状态失败时，会被加入同步队列，为了保证这个操作的安全性，使用compareAndSetTail(Node expect, Node update)来循环设置尾节点，直到操作成功为止。

---

同步队列遵循先进先出的策略，头节点释放同步状态后，唤醒后继节点，后继节点在获取同步状态成功后，会将自己设置为头节点。由于同步状态只会有一个线程获得，所以设置头节点的方法不需要CAS来保证，它只需要将首节点设置为原头节点的next节点，然后断开原头节点的next引用。

队列同步实现分析之独占式同步资源获取与释放

线程在获取同步资源失败后，进入同步队列，在同步队列中不会被中断，获取同步资源的代码：

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

1. 调用子类的tryAcquire方法尝试获得锁

// 首先判断锁的状态是否为0，如果是，就使用CAS获取锁，获取失败返回false
@Override
protected boolean tryAcquire(int state) {
    if (compareAndSetState(0, state)) {
        // 设置当前获得锁的线程
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}

2. 在尝试获得锁失败后，将当前线程构造节点加入到同步队列中，addWaiter()

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) {
        // 将新节点的prev指向原来的尾节点
        node.prev = pred;
        // 尝试将同步器的tail尾节点指向新节点
        if (compareAndSetTail(pred, node)) {
            // 修改成功后，新节点变成尾节点，将原尾节点的next指向新的尾节点
            pred.next = node;
            return node;
        }
    }
    // 如果当前同步器不存在尾节点（未初始化）
    // 或者新节点设置为尾节点失败，表示有多个线程在加入同步队列，调用enq方法，循环调用CAS设置节点为尾节点
    enq(node);
    return node;
}

private Node enq(final Node node) {
    // 循环一直执行
    for (;;) {
        Node t = tail;
        // 判断当前尾节点是否为空
        if (t == null) { // 进行同步队列初始化，占有同步状态的线程为head节点
            
            // 为空表示同步队列还没有节点，新建个节点加入到同步队列中
            // 这个新节点就是头结点，同步器的首节点head和尾节点tail都指向这个新节点
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 1. 已经初始化完成，将第一个阻塞的线程加入同步队列
            // 2. 或者之前有多个线程同时进入同步队列，设置尾节点时冲突，循环重新设置尾节点直到成功
            
            node.prev = t;	// 新的尾节点的prev为原尾节点
            if (compareAndSetTail(t, node)) {
                // CAS设置新的尾节点，设置成功后，将原尾节点的next指向新尾节点
                t.next = node;
                return t;
            }
        }
    }
}

3. 调用acquireQueued方法，节点进入同步队列后，线程不停的自旋获取同步状态，直到获取同步状态成功，退出循环。

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 线程不断自旋获取同步状态
        for (;;) {
            // 获取当前线程节点的prev节点
            final Node p = node.predecessor();
            
            // 如果前任节点是head节点，并且成功获取同步状态了，就退出循环
            if (p == head && tryAcquire(arg)) {
                // 设置新的头结点为成功获得同步状态的线程节点
                setHead(node);
                // 将原头结点的next置为null
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            // 先判断线程是否可以进入阻塞状态
            // 再调用LockSupport的park阻塞当前线程，线程被中断或者
            // 前序节点释放，当前线程才会苏醒，类似于wait/notify
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 标识在等待过程中是否受到中断
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}


// 设置头结点的方法
private void setHead(Node node) {
    head = node;
    // 头结点的thread都为null
    node.thread = null;
    // 将新的头结点的前任节点（原头结点）置为null，这样原头节点就跟同步队列脱离了
    node.prev = null;
}

// 判断当前线程是否可以直接进入阻塞状态
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // SINGAL标识节点在等待状态，当前线程可以安全的去阻塞了
        return true;
    if (ws > 0) {
        // 前序节点CANCELLED了，表示放弃了。那就一直往前找，找到最近的一个正常状态，然后排在它后面。
        // 那些无用的节点，由于被当前线程强行加塞到它们前边，相当于无用了，会被GC回收。
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 前驱节点正常，就把它设为SIGNAL，表示当前线程在等待状态。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

线程在死循环中尝试获取同步状态，并且在前节点是头结点时，才尝试获取同步状态。原因有以下2个：

• 头结点是占有同步状态的节点，当头节点的线程释放了同步状态后，将会唤醒其后续节点，后续节点需要检查自己的前序节点是头结点
• 维护队列的FIFO原则。由于非首节点线程前驱节点出队或者被中断从等待状态返回，检查自己的前驱节点是否是头结点，如果是就获取同步状态。节点跟节点在循环检查时，并不互相通信，只有前驱节点为头节点的线程才能获取同步状态，满足先进先出原则。

独占式同步资源获取流程：

4. 同步资源状态释放：release()

public final boolean release(int arg) {
    // 调用自定义的释放资源，将state改为0
    if (tryRelease(arg)) {
        Node h = head;
        // 同步队列还有节点，就唤醒头节点的next节点，并且开始尝试获取同步状态
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// 唤醒节点
private void unparkSuccessor(Node node) {
    // 重置头节点的等待状态
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    // 唤醒头结点的后续节点，如果后续节点为null或者等待状态为CANCELLED
    // 就往前找到最开头可以被唤醒的节点
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            // 等待状态<=0，表示这个线程没有放弃，还在等待
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        // 唤醒当前线程
        LockSupport.unpark(s.thread);
}

总结：在获取同步状态时，同步器维护一个先进先出的同步队列，当前线程获取同步失败后，就进入同步队列并且不断地自旋，直到前驱节点为头节点并且成功获得同步状态后，才会移出队列。在释放同步状态时，使用tryRelease(int arg)设置同步状态为0，并且唤醒头节点的后续节点。

队列同步实现分析之共享式同步资源获取与释放

共享式与独占式获取资源的区别是：是否允许多个线程同时访问共享资源。

当多个共享占有资源，独占式占用资源会被阻塞。

当独占式占用资源，共享式占有资源会被阻塞。

1. 同步器的acquireShared()方法和doAcquireShared()方法

public final void acquireShared(int arg) {
    // 调用自定义的获取共享同步资源，返回小于0，表示失败，进入阻塞等待
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
    // 添加一个共享式的节点放到同步队列中
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            // 前驱节点为头结点
            if (p == head) {
                // 尝试获取同步资源
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 获取成功后，将自己设为头结点，如果有剩余资源，唤醒别的线程。
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    if (interrupted)	// 如果唤醒过程中被中断，那么就补上中断
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            // 判断状态，寻找安全点，进入waiting状态
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

·这个跟独占式获取资源的过程差不多，就是设置头结点如果有剩余资源，就唤醒剩下的线程。

2. 释放共享式资源的方法：releaseShared()

public final boolean releaseShared(int arg) {
    // 调用自定义释放共享资源方法，如果成功，就唤醒后继节点
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

独占式获取资源跟共享式获取资源实现上的区别

• 这两种首先都是调用子类的获取资源方法，如果失败，往同步队列的尾部插入一个节点，插入尾节点循环使用compareAndSetTail()方法，保证插入成功。
• 然后线程进入自旋等待状态，直到被唤醒或者被中断。但是它们在没获得资源时，虽然被中断了，但是不会响应中断，而是会继续排队下去。只是在最后拿到资源时，如果中间被中断过，再自己中断自己。
• 在自旋等待时，取当前节点的前驱节点。在独占式中，判断前驱节点是头结点并且调用tryAccquire()方法成功，就设置自己为头节点，断开原头结点的引用。而在共享式中，判断前驱节点是头结点，调用tryAccquireShared()返回结果成功，设置自己为头结点，并且有剩余资源时，唤醒其他节点。

可响应中断的获取资源

可响应中断跟其他的区别就是，在阻塞排队的过程中，如果被中断了，直接抛出异常，并不会继续排队下去。

private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    // 被唤醒之后，如果被中断了，直接抛异常退出排队。
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

###7.2.7超时中断的获取资源

对于普通的可响应中断，在排队等待获取资源时，如果被中断了，会抛出异常并立即返回。

超时中断就是它的增强版，不光是中断会返回，在等待时间超出后也会直接返回。

private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    // 等待超时时间
    final long deadline = System.nanoTime() + nanosTimeout;
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            // 当前等待剩余时间
            nanosTimeout = deadline - System.nanoTime();
            // 等待时间到，直接返回
            if (nanosTimeout <= 0L)
                return false;
            // 等待时间如果不足1000L，也不会休眠，直接进行超快循环自旋
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                // 否则就等待对应的时间
                LockSupport.parkNanos(this, nanosTimeout);
            // 等待过程中被中断，直接抛异常返回
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

自定义共享锁

/**
 * 一个共享锁，最多可以供2个线程同时访问
 * @author xu hao
 * @createTime 2019/4/22 14:57.
 */
public class TwinLock implements Lock{
    
    private static final Sync SYNC = new Sync();

    static class Sync extends AbstractQueuedSynchronizer {

        public Sync() {
            // 初始化状态2
            setState(2);
        }

        // 共享获得锁，state为0,1,2分别表示剩余资源为0,1,2
        @Override
        protected int tryAcquireShared(int arg) {
            for (;;) {
                int state = getState();
                if (state > 0 ) {
                    if (compareAndSetState(state, state - arg)) {
                        return 1;
                    }
                }
                return -1;
            }
        }

        // 共享释放锁
        @Override
        protected boolean tryReleaseShared(int arg) {
            for (;;) {
                int state = getState();
                // 这里使用循环CAS，可能有多个锁同时释放，保证操作的原子性
                if (compareAndSetState(state, state + arg)) {
                    return true;
                }
            }
        }
    }

    @Override
    public void lock() {
        SYNC.acquireShared(1);
    }

    @Override
    public void unlock() {
        SYNC.releaseShared(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        SYNC.acquireSharedInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        if (SYNC.tryAcquireShared(1) > 0) {
            return true;
        }
        return false;
    }
    
    ...其他接口的实现
}

使用这个自定义锁：

public class TwinLockTest {

    private static final TwinLock TWIN_LOCK = new TwinLock();

    private static final int THREADS_COUNT = 20;

    private static final CountDownLatch LATCH = new CountDownLatch(THREADS_COUNT);

    static class Runner implements Runnable {

        @Override
        public void run() {
            TWIN_LOCK.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "拿到锁，休眠2秒");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread().getName() + "休眠回来，释放锁");
                TWIN_LOCK.unlock();
                LATCH.countDown();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < THREADS_COUNT; i++) {
            new Thread(new Runner()).start();
        }
        LATCH.await();
        System.out.println("执行完成。。。");
    }
}

// 输出结果：每次都有2个线程获取同步资源
Thread-0拿到锁，休眠2秒
Thread-1拿到锁，休眠2秒
Thread-0休眠回来，释放锁
Thread-1休眠回来，释放锁
Thread-3拿到锁，休眠2秒
Thread-2拿到锁，休眠2秒
Thread-3休眠回来，释放锁
Thread-2休眠回来，释放锁
Thread-5拿到锁，休眠2秒
Thread-4拿到锁，休眠2秒
Thread-4休眠回来，释放锁
Thread-5休眠回来，释放锁