011Java并发包015AQS

注意：本文基于JDK1.8进行记录。

 

1 简介

1.1 是什么

AQS是英文单词AbstractQueuedSynchronizer的缩写，翻译过来就是抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock、Semaphore、CountDownLatch等等。

AQS是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个state整型变量表示持有锁的状态。

1.2 抽象

AQS的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态。

1.3 原理

抢到资源的线程直接使用处理业务逻辑，抢不到资源的必然涉及一种排队等候机制。既然说到了排队等候机制，那么就一定会有某种队列形成，这样的队列是什么数据结构呢。

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

CLH：Craig、Landin、Hagersten（三个科学家名字）队列，原版是一个单向链表，AQS中的队列是CLH变体的虚拟双向队列FIFO，其头节点在初始化后变为空节点。

1.4 资源使用方式

AQS定义两种资源使用方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

2 体系架构

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    ...
    // 内部封装Node节点
    static final class Node {
        // 标记线程以共享的模式等待锁
        static final Node SHARED = new Node();
        // 标记线程以独占的模式等待锁
        static final Node EXCLUSIVE = null;
        // waitStatus取值为1表示线程取消（超时、中断），被取消的节点不会阻塞
        static final int CANCELLED =  1;
        // waitStatus取值为-1表示后继节点已经准备完成，等待线程释放资源
        static final int SIGNAL    = -1;
        // waitStatus取值为-2表示线程在Condition队列中阻塞，当其他线程调用了Condition中的唤醒方法后，将节点从Condition队列转移到CLH等待队列（Condition中有使用）
        static final int CONDITION = -2;
        // waitStatus取值为-3表示线程及后续线程无条件传播（共享模式可用，CountDownLatch中有使用）
        static final int PROPAGATE = -3;
        // 线程的等待状态，初始值为0
        volatile int waitStatus;
        // 前驱节点
        volatile Node prev
        // 后继节点
        volatile Node next;
        // 线程对象
        volatile Thread thread;
        ...
    }
    // 头节点
    private transient volatile Node head
    // 尾节点
    private transient volatile Node tail;
    // 资源状态，0表示可获取，大于等于1表示已占用
    private volatile int state;
    // 获取资源状态
    protected final int getState() {
        return state;
    }
    // 设置资源状态
    protected final void setState(int newState) {
        state = newState;
    }
    // CAS设置资源状态
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
    ...
}

AQS使用了一个volatile修饰的整型变量state用来表示同步状态，通过内置的CLH同步队列来完成线程的排队工作。

其中，对state值的修改是通过CAS完成的，0表示资源可用，大于等于1表示资源不可用。AQS提供了三种操作state的方法：getState()、setState()、compareAndSetState()。

当前线程根据state的值判断能否获取资源，如果获取失败，AQS会将当前线程thread以及等待状态waitStatus等信息封装成Node节点，并将其加CLH入同步队列，同时阻塞当前线程。当state的值变为可获取资源后，会把Node节点中的线程唤醒，再次尝试获取资源。

3 Lock与AQS

Lock接口的实现类，基本都是通过聚合了一个队列同步器的子类完成线程访问控制的。

public class ReentrantLock implements Lock, java.io.Serializable {
    ...
    abstract static class Sync extends AbstractQueuedSynchronizer {
        ...
        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;
        }
        ...
    }
    static final class NonfairSync extends Sync {
        ...
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
    static final class FairSync extends Sync {
        ...
        final void lock() {
            acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
        }
    }
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    ...
}

ReentrantLock类的内部聚合了一个Sync类，Sync类继承了AQS类，并且非公平锁NonfairSync和公平锁FairSync都继承自Sync，默认创建的是非公平锁NonfairSync。

4 分析ReentrantLock

4.1 概述

整个ReentrantLock的加锁过程，可以分为三个阶段：

1）尝试加锁。

2）加锁失败，线程入队列。

3）线程入队列后，进入阻赛状态。

4.2 场景举例

举例三个客户在银行办理业务，使用默认的非公平锁：

public static void main(String[] args) {
    Lock lock = new ReentrantLock();
    new Thread(()->{
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "-----办理业务");
            try {
                TimeUnit.SECONDS.sleep(60);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-----离开");
        } finally {
            lock.unlock();
        }
    }, "A").start();
    new Thread(()->{
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "-----办理业务");
            try {
                TimeUnit.SECONDS.sleep(60);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-----离开");
        } finally {
            lock.unlock();
        }
    }, "B").start();
    new Thread(()->{
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "-----办理业务");
            try {
                TimeUnit.SECONDS.sleep(60);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-----离开");
        } finally {
            lock.unlock();
        }
    }, "C").start();
}

5 程序分析

5.1 线程A开始并执行

5.1.1 获取资源

线程A进入，调用lock()方法，查看实现：

final void lock() {
    // 使用CAS设置state为1
    if (compareAndSetState(0, 1))
        // 表示获取资源成功，将当前线程设为占用线程
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 表示获取资源失败，继续抢占资源
        acquire(1);
}

因为线程A是第一个获取资源的线程，所以使用compareAndSetState()方法设置成功，继续调用setExclusiveOwnerThread()方法将当前线程设为占用线程，然后继续执行业务。

5.2 线程B开始并阻塞

5.2.1 获取资源

线程B进入，调用lock()方法。

因为线程B是第二个获取资源的线程，线程A已经将state从0改为了1，所以使用compareAndSetState()方法设置失败。

5.2.2 抢占资源

线程B进入，继续调用acquire()方法抢占资源，查看实现：

public final void acquire(int arg) {
    // 抢占资源
    if (!tryAcquire(arg) &&
        // 加入等待队列
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 线程阻塞
        selfInterrupt();
}

继续调用tryAcquire()方法抢占资源，查看实现：

protected final boolean tryAcquire(int acquires) {
    // 继续调用非公平锁的尝试抢占方法
    return nonfairTryAcquire(acquires);
}

继续调用非公平锁的nonfairTryAcquire()方法，返回false表示占用失败：

final boolean nonfairTryAcquire(int acquires) {
    // 记录当前线程
    final Thread current = Thread.currentThread();
    // 记录当前资源状态
    int c = getState();
    // 0表示当前资源可用
    if (c == 0) {
        // 使用CAS设置state为请求数
        if (compareAndSetState(0, acquires)) {
            // 表示获取资源成功，将当前线程设为占用线程
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 大于等于1表示当前资源被占用，判断当前线程是否为占用线程（可重入锁的情况）
    else if (current == getExclusiveOwnerThread()) {
        // 当前线程为占用线程，记录资源状态
        int nextc = c + acquires
        // 判断是否溢出
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 设置state为新的资源状态
        setState(nextc);
        return true;
    }
    return false;
}

因为线程B是第二个获取资源的线程，线程A已经将state从0改为了1，返回false，将当前线程加入等待队列并阻塞。

5.2.3 进入等待

线程B进入，继续调用addWaiter()方法将当前线程加入等待队列，查看实现：

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;
    // 尾节点不为空，表示CLH队列已经初始化，CAS操作将当前节点设为尾节点
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 尾节点为空，表示CLH队列还未初始化，初始化队列
    enq(node);
    return node;
}

因为线程B是第一个进入等待的线程，尾节点为空，继续查看enq()方法：

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // 尾节点为空，通过CAS设置头节点和尾节点为空节点
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 尾节点不为空，通过CAS将当前节点作为新的尾节点
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

初始化CLH队列后，头节点为空节点，尾节点为当前节点。

5.2.4 阻塞线程

线程B得到当前节点后，作为参数传入acquireQueued()方法继续执行：

final boolean acquireQueued(final Node node, int arg) {
    // 记录当前节点是否取消，默认为true，表示取消
    boolean failed = true;
    try {
        // 标记当前节点是否中断，默认为false，表示当前节点没有中断
        boolean interrupted = false
        // 自旋
        for (;;) {
            // 获取当前节点的上一节点
            final Node p = node.predecessor();
            // 如果当前节点是头节点，表示当前节点即将被唤醒，尝试抢占资源
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设为头节点，置空当前节点的上一节点，并取消当前节点同当前线程的绑定
                setHead(node);
                // 将原头节点的下一节点置空，方便GC回收
                p.next = null; // help GC
                // 标记当前节点为false，表示没有取消
                failed = false;
                // 返回false，表示当前节点没有中断
                return interrupted;
            }
            // 不管当前节点是不是头节点，执行到这里就表示获取资源失败，处理前置节点并阻塞当前节点
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 标记为true，表示当前节点中断
                interrupted = true;
        }
    } finally {
        // 当前节点如果被取消，执行取消操作
        if (failed)
            cancelAcquire(node);
    }
}

因为线程B是第一个进入等待的线程，上一节点为头节点，尝试获取资源。获取成功则将当前节点作为头节点并移除当前线程，获取失败则进入判断。

在判断条件中调用shouldParkAfterFailedAcquire()方法，处理前置节点：

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 记录上一节点的等待状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 如果上一节点的等待状态为-1，表示当前线程可以被阻塞，返回true，执行parkAndCheckInterrupt()方法
        return true;
    if (ws > 0) {
        // 如果上一节点的等待状态为1，表示上一节点被取消，循环移除被取消的上一节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 上述条件不满足，表示上一节点的等待状态为0或者-3，通过CAS将等待状态设置为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回false，跳过parkAndCheckInterrupt()方法，重新进入自旋
    return false;
}

因为线程B是第一个进入等待的线程，上一节点为头节点，头节点为空节点，等待状态为0，所以两次进入此方法。

第一次进入shouldParkAfterFailedAcquire()方法将上一节点的等待状态设置为-1后返回false，条件判断为false重新进入自旋。

第二次进入shouldParkAfterFailedAcquire()方法检测到上一节点的等待状态为-1，返回true，继续判断parkAndCheckInterrupt()方法。

在判断条件中调用parkAndCheckInterrupt()方法，阻塞当前节点：

private final boolean parkAndCheckInterrupt() {
    // 使用LockSupport的park()方法阻塞当前节点
    LockSupport.park(this);
    // 返回线程的中断状态
    return Thread.interrupted();
}

线程B在此被阻塞。

5.3 线程C开始并阻塞

5.3.1 获取资源

线程C进入，调用lock()方法。

因为线程C是第三个获取资源的线程，线程A已经将state从0改为了1，所以使用compareAndSetState()方法设置失败。

5.3.2 抢占资源

线程C进入，继续调用acquire()方法抢占资源。

继续调用tryAcquire()方法抢占资源。

继续调用非公平锁的nonfairTryAcquire()方法，返回false表示占用失败。

因为线程C是第三个获取资源的线程，线程A已经将state从0改为了1，返回false，将当前线程加入等待队列并阻塞。

5.3.3 进入等待

线程C进入，继续调用addWaiter()方法将当前线程加入等待队列。

因为线程C是第二个进入等待的线程，线程B已经完成了队列初始化，尾节点不为空，将当前节点作为新的尾节点。

5.3.4 阻塞线程

线程C得到当前节点后，作为参数传入acquireQueued()方法继续执行。

因为线程C是第二个进入等待的线程，上一节点不为头节点，直接进入判断。

在判断条件中调用shouldParkAfterFailedAcquire()方法，处理前置节点，将B节点的等待状态设为-1，返回true，继续判断parkAndCheckInterrupt()方法。

在判断条件中调用parkAndCheckInterrupt()方法，阻塞当前节点。

线程C在此被阻塞。

5.4 线程A结束

5.4.1 解锁资源

线程A执行完毕，调用unlock()方法释放资源并唤醒线程，查看实现：

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

继续查看release()方法：

public final boolean release(int arg) {
    // 调用tryRelease()方法尝试释放资源
    if (tryRelease(arg)) {
        // 获取头节点
        Node h = head;
        // 如果头节点不为空，并且等待状态不为0，表示需要唤醒其他线程
        if (h != null && h.waitStatus != 0)
            // 调用unparkSuccessor()方法并传入头节点，唤醒线程
            unparkSuccessor(h);
        return true;
    }
    // 释放失败返回false
    return false;
}

5.4.2 释放资源

继续查看tryRelease()方法：

protected final boolean tryRelease(int releases) {
    // 记录资源状态
    int c = getState() - releases;
    // 如果当前线程不为占用线程则抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 标记资源空闲，默认为false
    boolean free = false
    // 资源状态为0则标记资源空闲为true，并将占用线程置空
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 设置资源状态
    setState(c);
    // 返回资源空闲
    return free;
}

线程A释放资源并返回true，继续执行。

5.4.3 唤醒线程

因为线程B和线程C已经进入等待队列，所以头节点不为空，继续查看unparkSuccessor()方法：

private void unparkSuccessor(Node node) {
    // 记录头节点的等待状态
    int ws = node.waitStatus;
    // 如果头节点的等待状态小于0，则将头节点的等待状态设为0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 记录头节点的下一节点
    Node s = node.next;
    // 判断下一节点是否为空或者下一节点的等待状态是否大于0
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 遍历下一节点，找到不为空并且等待状态小于等于0的节点，将其设为下一节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 如果下一节点不为空，则使用LockSupport的unpark()方法唤醒下一节点中的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

头节点的下一节点为线程B所在的节点，线程B被唤醒。

5.5 线程B执行并结束

5.5.1 抢占资源

线程B在parkAndCheckInterrupt()方法中被释放后，返回中断状态为false，重新进入自旋：

final boolean acquireQueued(final Node node, int arg) {
    // 记录当前节点是否取消，默认为true，表示取消
    boolean failed = true;
    try {
        // 标记当前节点是否中断，默认为false，表示当前节点没有中断
        boolean interrupted = false
        // 自旋
        for (;;) {
            // 获取当前节点的上一节点
            final Node p = node.predecessor();
            // 如果当前节点是头节点，表示当前节点即将被唤醒，尝试抢占资源
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设为头节点，置空当前节点的上一节点，并取消当前节点同当前线程的绑定
                setHead(node);
                // 将原头节点的下一节点置空，方便GC回收
                p.next = null; // help GC
                // 标记当前节点为false，表示没有取消
                failed = false;
                // 返回false，表示当前节点没有中断
                return interrupted;
            }
            // 不管当前节点是不是头节点，执行到这里就表示获取资源失败，处理前置节点并阻塞当前节点
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 标记为true，表示当前节点中断
                interrupted = true;
        }
    } finally {
        // 当前节点如果被取消，执行取消操作
        if (failed)
            cancelAcquire(node);
    }
}

因为线程B的上一节点为头节点，进入tryAcquire()方法抢占资源，抢占成功返回true并将当前节点设为头节点，同时解除同线程B的绑定。

5.5.2 解锁资源

线程B执行完毕，调用unlock()方法释放资源并唤醒线程。

头节点的下一节点为线程C所在的节点，线程C被唤醒。

5.6 线程C执行并结束

5.6.1 抢占资源

线程C在parkAndCheckInterrupt()方法中被释放后，返回中断状态为false，重新进入自旋。

因为线程C的上一节点为头节点，进入tryAcquire()方法抢占资源，抢占成功返回true并将当前节点设为头节点，同时解除同线程C的绑定。

5.6.2 解锁资源

线程C执行完毕，调用unlock()方法释放资源并唤醒线程。

头节点的下一节点为空，不会有任何线程被唤醒。

6 公平锁与非公平锁

6.1 非公平锁

非公平锁的线程在获取资源时，会尝试获取资源，如果成功则立刻占用资源，如果失败则尝试占用资源。

在资源可用时不会判断当前队列是否有线程在等待，也就是说刚加入的线程可以同唤醒的线程竞争资源。

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;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

6.2 公平锁

公平锁的线程在获取资源时，不会尝试获取资源，而是尝试占用资源。

在资源可用时会判断当前队列是否有线程在等待，刚加入的线程不可用同唤醒的线程竞争资源。

final void lock() {
    acquire(1);
}
...
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
...
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        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;
}

6.3 分析hasQueuedPredecessors()方法

比较NonfairSync和FairSync中tryAcquire()方法的实现，发现FairSync中的tryAcquire()方法中多了一项判断：

!hasQueuedPredecessors()

hasQueuedPredecessors()方法用于公平锁加锁时判断等待队列中是否存在有效节点的方法。该方法用于判断当前节点前是否有其他节点排队：

返回false表示没有，取反后为true表示当前节点不需要排队，需要继续执行占用资源的操作。

返回true表示有，取反后为false表示当前节点需要排队，需要执行加入等待队列的操作。

查看AQS中定义的hasQueuedPredecessors()方法：

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    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());
}

判断h是否不等于t，如果不成立，说明h等于t，说明头节点和尾节点相同，说明当前队列未初始化（头节点和尾节点都是空节点）或者当前队列只有一个节点（头结点和尾节点都是空节点），说明不需要排队，返回false，取反后为true，尝试占用资源。

判断h是否不等于t，如果成立，说明h不等于t，说明存在两个不同节点。继续判断头节点的下一节点是否为空节点，如果成立，说明下一节点为空，可能上个线程在执行初始化enq()方法，刚刚通过CAS操作compareAndSetHead()将头节点初始化，尚未给尾节点赋值，此时头节点不为空，尾节点为空，并且头节点的下一节点为空，返回true，取反后为false，需要排队。

判断h是否不等于t，如果成立，说明h不等于t，说明存在两个不同节点。继续判断头节点的下一节点是否为空节点，如果不成立，说明下一节点不为空。继续判断下一节点封装的线程是否不等于当前线程，如果成立，说明下一线程不为当前线程，返回true，取反后为false，需要排队。

判断h是否不等于t，如果成立，说明h不等于t，说明存在两个不同节点。继续判断头节点的下一节点是否为空节点，如果不成立，说明下一节点不为空。继续判断下一节点封装的线程是否不等于当前线程，如果不成立，说明下一线程为当前线程，返回false，取反后为true，尝试占用资源。

7 自定义同步器

7.1 实现方法

不同的自定义同步器争用共享资源的方式也不同，自定义同步器在实现时只需要实现共享资源state的获取与释放即可，至于具体线程等待队列的维护（如获取资源失败入队和唤醒出队等），AQS已经在底层实现好了。

自定义同步器实现时主要实现以下几种方法：

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。

tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。

tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。

tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

7.2 举例说明

7.2.1 ReentrantLock

以ReentrantLock为例，state初始化为0，表示未锁定状态。

当线程A调用lock()方法获取资源时，会调用tryAcquire()占用资源，并将state的值加1。

此后，其他线程再tryAcquire()时就会失败，直到线程A调用unlock()方法释放资源，并将state的值减0，其它线程才有机会获取该锁。

当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多少次，这样才能保证state是能回到零态的。

7.2.2 CountDownLatch

再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（N与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后都会调用一次countDown()方法，使用CAS操作将state值减1。等到所有子线程都执行完后，state的值变为0，这时会调用unpark()方法唤醒主线程，然后主线程就会从await()方法唤醒，继续后余动作。