java并发编程（十七）带你了解什么是面试官常说的AQS

2022-01-13 本文已影响0人我犟不过你

前面我们学习了ReentrantLock，其底层就是用了AQS实现的，应该先讲这一章节，但是当时给忘了，现在给补上吧。

关于ReentrantLock的学习，可以参考：https://www.jianshu.com/p/edec5185196d

AbstractQueuedSynchronizer是阻塞式锁，以及同步器组件的实现框架。是JDK中实现并发编程的核心，它提供了一个基于FIFO队列，平时我们工作中经常用到的ReentrantLock，CountDownLatch等都是基于它来实现的。

一、初识AQS

首先我们还是从前面学习的ReentrantLock入手，看看其代码结构是什么样的：

ReentrantLockl类图

从上图可以看到以下几点：

ReentrantLock实现接口Lock（抽象接口）
ReentrantLock有三个内部类，分别是FrairSync、NonfairSync、Sync，且FrairSync、NonfairSync继承自Sync。
Sync继承AbstractQueuedSynchronizer
AbstractQueuedSynchronizer有两个内部类，分别是Node、ConditionObject。
AbstractQueuedSynchronizer继承自AbstractOwnableSynchronizer（抽象类，提供独占线程的get和set）。

AQS有如下的特点：

用 state 属性来表示资源的状态，包含独占状态和共享状态，对应公平锁和非公平锁。子类需要定义如何维护这个状态，控制如何获取锁和释放锁，如上面图中的关系，公平锁和非公平锁需要各自去维护这个state，达到获取和释放锁的目的。
- getState - 获取 state 状态
- setState - 设置 state 状态
- compareAndSetState - 使用CAS设置状态
- 独占模式：只有一个线程能够访问资源
- 共享模式：允许多个线程访问资源
提供了基于 FIFO 的等待队列，类似于前面讲Synchronized原理提到的 Monitor 的 EntryList
使用条件变量来实现等待队列、线程唤醒机制，同时支持多个条件变量，类似于前面讲Synchronized原理提到的 Monitor 的 WaitSet
【公平锁】与【非公平锁】：二者的区别主要在于获取锁是否和排队顺序有关。当锁呗一个线程持有，其他尝试获取锁的线程会被挂起，加到等待队列中，先被挂起的在队列的最前端。当锁被释放，需要通知队列中的线程。作为公平锁，会先唤醒队列最前端的线程；而非公平锁会唤醒所有线程，通过竞争去获取锁，后来的线程有可能获得锁。

二、源码分析

下面我们通过源码剖析其本质是什么样的。

首先在脑海中有个印象，AQS维护了两个对个队列，一个是同步队列，一个是阻塞队列。

Node可以说是【同步队列】和【阻塞队列】的节点。

2.1 Node源码剖析

  static final class Node {
    // 模式，分为共享与独占
    // 共享模式
    static final Node SHARED = new Node();
    // 独占模式
    static final Node EXCLUSIVE = null;        
    // 结点状态
    // CANCELLED，值为1，表示当前的线程被取消
    // SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark
    // CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中
    // PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行
    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;
    
    // 结点是否在共享模式下等待
    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
    }
    
    // 构造函数，被addWaiter使用
     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;
    }
}

2.2 ConditionObject源码剖析

实现了condition接口，关于condition的学习后面会介绍，在学习ReentrantLock时也介绍了其使用方式。

代码较多，直接从上向下看吧：

 // 内部类
public class ConditionObject implements Condition, java.io.Serializable {
    // 版本号
    private static final long serialVersionUID = 1173984872572414699L;
    
    // condition队列的头结点
    private transient Node firstWaiter;
    
    // condition队列的尾结点
    private transient Node lastWaiter;

    /**
     *  构造函数
     */
    public ConditionObject() { }

    /**
     * 添加新的waiter到wait队列
     */
    private Node addConditionWaiter() {
        // 定义尾结点是t
        Node t = lastWaiter;
       // 尾结点不为空，并且尾结点的状态不为CONDITION（默认是-2，表示当前节点在conditionObject等待队列中）
        if (t != null && t.waitStatus != Node.CONDITION) { 
            // 清除状态不为CONDITION的结点，对firstWaiter和lastWaiter重新赋值
            unlinkCancelledWaiters(); 
            // 将最后一个结点重新赋值给t
            t = lastWaiter;
        }
        // 新建一个结点
        Node node = new Node(Thread.currentThread(), Node.CONDITION);
        // 尾结点为空
        if (t == null) 
            // 设置condition队列的头结点
            firstWaiter = node;
        else 
            // 设置为节点的nextWaiter域为node结点
            t.nextWaiter = node;
        // 更新condition队列的尾结点
        lastWaiter = node;
        return node;
    }

    /**
     *  移除或转移头结点到sync队列，直到没有取消的或者空为止
     */
    private void doSignal(Node first) {
        // 循环
        do {
            // 将下一个节点设为首节点，如果为空
            if ( (firstWaiter = first.nextWaiter) == null) 
                // 设置尾结点为空
                lastWaiter = null;
            // 设置first结点的nextWaiter域
            first.nextWaiter = null;
        } while (!transferForSignal(first) &&
                 (first = firstWaiter) != null); // 将结点从condition队列转移到sync队列失败并且condition队列中的头结点不为空，一直循环
    }

    /**
     * 转移所有等待队列的节点到同步队列
     */
    private void doSignalAll(Node first) {
        // condition队列的头结点尾结点都设置为空
        lastWaiter = firstWaiter = null;
        // 循环
        do {
            // 获取first结点的nextWaiter域结点
            Node next = first.nextWaiter;
            // 设置first结点的nextWaiter域为空
            first.nextWaiter = null;
            // 将first结点从condition队列转移到sync队列
            transferForSignal(first);
            // 重新设置first
            first = next;
        } while (first != null);
    }

    /**
     * 过滤掉状态不为CONDITION的节点
     * 对firstWaiter和lastWaiter重新赋值
     **/
    private void unlinkCancelledWaiters() {
        // 获取condition队列头结点
        Node t = firstWaiter;
        // 获取一个尾结点是null
        Node trail = null;
        while (t != null) {
            // 获取下一个结点
            Node next = t.nextWaiter;
            // 头结点的状态不为CONDTION状态
            if (t.waitStatus != Node.CONDITION) { 
                // 设置t节点的下一个等待者为空
                t.nextWaiter = null;
                if (trail == null) // trail为空，首次进来一定为空
                    // 重新设置condition队列的头结点
                    firstWaiter = next;
                else 
                    // 设置trail结点的nextWaiter域为next结点
                    trail.nextWaiter = next;
                if (next == null) // next结点为空
                    // 设置condition队列的尾结点
                    lastWaiter = trail;
            }
            else // t结点的状态为CONDTION状态
                // 设置trail结点
                trail = t;
            // 设置t结点
            t = next;
        }
    }

    /**
     * 实现Condition接口的signal方法
     */
    public final void signal() {
        if (!isHeldExclusively()) // 不被当前线程独占，抛出异常
            throw new IllegalMonitorStateException();
        // 保存condition队列头结点
        Node first = firstWaiter;
        if (first != null) // 头结点不为空
            // 唤醒一个等待线程，将头结点从阻塞队列移除，添加到同步队列
            doSignal(first);
    }

    /**
     * 实现Condition的signalAll方法，唤醒所有线程
     */
    public final void signalAll() {
        if (!isHeldExclusively()) // 不被当前线程独占，抛出异常
            throw new IllegalMonitorStateException();
        // 保存condition队列头结点
        Node first = firstWaiter;
        if (first != null) // 头结点不为空
            // 唤醒所有等待线程，将头结点从阻塞队列移除，添加到同步队列
            doSignalAll(first);
    }

    /**
     * 与await()区别在于，使用await方法，调用interrupt()中断后会报错，而该方法不会报错。
     */
    public final void awaitUninterruptibly() {
        // 添加一个结点到等待队列
        Node node = addConditionWaiter();
        // 获取释放的状态
        int savedState = fullyRelease(node);
        boolean interrupted = false;
        while (!isOnSyncQueue(node)) { // 
            // 阻塞当前线程
            LockSupport.park(this);
            if (Thread.interrupted()) // 当前线程被中断
                // 设置interrupted状态
                interrupted = true; 
        }
        if (acquireQueued(node, savedState) || interrupted) // 
            selfInterrupt();
    }

    /**
     *  等待，当前线程在接到信号或被中断之前一直处于等待状态
     */
    public final void await() throws InterruptedException {
        // 当前线程被中断，抛出异常
        if (Thread.interrupted()) 
            throw new InterruptedException();
        // 将当前线程包装成Node，尾插入到等待队列中
        Node node = addConditionWaiter();
        // 释放当前线程所占用的lock，在释放的过程中会唤醒同步队列中的下一个节点
        int savedState = fullyRelease(node);
        int interruptMode = 0;
        while (!isOnSyncQueue(node)) {
            // 当前线程进入到等待状态
            LockSupport.park(this);
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) // 检查结点等待时的中断类型
                break;
        }
        // 自旋等待获取到同步状态（即获取到lock）
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        if (node.nextWaiter != null) // clean up if cancelled
            unlinkCancelledWaiters();
        // 处理被中断的情况
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }

    /**
     * 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态
     */
    public final long awaitNanos(long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        Node node = addConditionWaiter();
        int savedState = fullyRelease(node);
        final long deadline = System.nanoTime() + nanosTimeout;
        int interruptMode = 0;
        while (!isOnSyncQueue(node)) {
            if (nanosTimeout <= 0L) {
                transferAfterCancelledWait(node);
                break;
            }
            if (nanosTimeout >= spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
            nanosTimeout = deadline - System.nanoTime();
        }
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        if (node.nextWaiter != null)
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
        return deadline - System.nanoTime();
    }

    /**
     * 等待，当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态
     */
    public final boolean awaitUntil(Date deadline)
            throws InterruptedException {
        long abstime = deadline.getTime();
        if (Thread.interrupted())
            throw new InterruptedException();
        Node node = addConditionWaiter();
        int savedState = fullyRelease(node);
        boolean timedout = false;
        int interruptMode = 0;
        while (!isOnSyncQueue(node)) {
            if (System.currentTimeMillis() > abstime) {
                timedout = transferAfterCancelledWait(node);
                break;
            }
            LockSupport.parkUntil(this, abstime);
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
        }
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        if (node.nextWaiter != null)
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
        return !timedout;
    }

    /**
     * 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。此方法在行为上等              
     * 效于：awaitNanos(unit.toNanos(time)) > 0
     */
    public final boolean await(long time, TimeUnit unit)
            throws InterruptedException {
        long nanosTimeout = unit.toNanos(time);
        if (Thread.interrupted())
            throw new InterruptedException();
        // 1. 将当前线程包装成Node，尾插入到等待队列中
        Node node = addConditionWaiter();
        // 2. 释放当前线程所占用的lock，在释放的过程中会唤醒同步队列中的下一个节点
        int savedState = fullyRelease(node);
        final long deadline = System.nanoTime() + nanosTimeout;
        boolean timedout = false;
        int interruptMode = 0;
        while (!isOnSyncQueue(node)) {
            if (nanosTimeout <= 0L) {
                timedout = transferAfterCancelledWait(node);
                break;
            }
            if (nanosTimeout >= spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
            nanosTimeout = deadline - System.nanoTime();
        }
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        if (node.nextWaiter != null)
            unlinkCancelledWaiters();
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
        return !timedout;
    }

2.3 锁的获取和释放

整个AQS的设计理念就是通过state字段来实现锁的获取和释放，锁有主要分为公平锁和非公平锁。

2.3.1 公平锁

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            // 继承自AQS的方法，内部先调用tryAcquire获取锁，获取失败则添加下城到等待队列当中
            acquire(1);
        }

        /**
         * 公平锁版本的tryAcquire
         */
        protected final boolean tryAcquire(int acquires) {
            // 获取当前线程
            final Thread current = Thread.currentThread();
            // 获取锁的状态
            int c = getState();
            // 0表示锁没有被持有
            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;
        }
    }

2.3.2 非公平锁

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * 立即获取锁，失败会加入等待队列
         */
        final void lock() {
            // 通过CAS尝试获取锁，成功则设置当前线程独占
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 否则加入等待队列·····································································································································
                acquire(1);
        }

        /** 
          * 非公平锁版本的tryAcquire
          */
        protected final boolean tryAcquire(int acquires) {
            // 走其父类Sync的默认nonfairTryAcquire
            return nonfairTryAcquire(acquires);
        }
    }

2.3.3 Syc子类

这是公平锁和非公平锁的父类，提供统一的tryRelease方法释放锁

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * 提供非公平版本的快捷路径
         */
        abstract void lock();

        /**
         * 非公平锁获取，默认就是非公平锁
         */
        final boolean nonfairTryAcquire(int acquires) {
            // 获取当前线程
            final Thread current = Thread.currentThread();
            // 获取当前锁的状态
            int c = getState();
            // 0表示没有被占用
            if (c == 0) {
                // CAS占用，成功则设置当前线程为独占锁
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 当前线程是独占锁，表示锁重入
            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;
        }

         /**
         * 释放锁
         */
        protected final boolean tryRelease(int releases) {
            // 当前状态 减去 释放的数量
            int c = getState() - releases;
            // 如果当前线程不是占有锁的线程，抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            // 当全部释放后，状态为0，取消独占线程
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            // 设置状态为0，返回释放成功
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            // 当前线程是否是锁持有者
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        // 获取当前持有者
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        // 获取持有数，只有是线程持有者才能获取
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }
    }

3.3.4 acquire 和 release

在AQS当中还有两个核心方法：

acquire()：获取锁，这是实际锁调用上锁的真正方法，前面的try开头的知识尝试获取锁，即使失败也不会添加到等待队列。

    public final void acquire(int arg) {
      // 尝试获取
      if (!tryAcquire(arg) &&
          // 尝试获取成功，以独占方式添加到等待队列，并不断地尝试占有锁知道成功
          acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          selfInterrupt();
  }

release()：释放锁，这是实际释放锁的方法，会调用锁自定义的同步器实现的tryRelease方法：

    /**
      * 尝试释放，成功后返回true
      */
    public final boolean release(int arg) {
      if (tryRelease(arg)) {
          Node h = head;
          if (h != null && h.waitStatus != 0)
              unparkSuccessor(h);
          return true;
      }
      return false;
  }

后面我们自定义不可重入锁，来看看同步器和锁的关系是什么样的，加深理解。

2.4 简单总结

到此为止，通过阅读前面的源码内容，我们可以有如下的总结：

锁的释放和获取都是围绕【state】来做的，0表示未持有锁，1表示独占，大于一表示锁重入

获取锁的姿势如下：

  // 如果获取锁失败
  if (!tryAcquire(arg)) {
    // 入队, 可以选择阻塞当前线程 park unpark
  }

释放锁的姿势如下：

  // 如果获取锁成功
  if (!tryRelease(arg)) {
    // 让阻塞线程恢复运行
  }

三、实践

了解了AQS的结构之后，我们不妨自己动手实践一番。加深理解。

定义一个不可重入锁，需要一个同步器，一个锁，一个测试类

自定义同步器：

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * @description： 实现一个不可重入锁 同步器，state最大只能是1
 * @author：weirx
 * @date：2022/1/13 13:49
 * @version：3.0
 */
public class MyLockSynchronizer extends AbstractQueuedSynchronizer {

    @Override
    protected boolean tryAcquire(int acquires) {
        int state = getState();
        if (state == 0) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
        }
        return false;
    }

    @Override
    protected boolean tryRelease(int acquires) {
        int c = getState() - acquires;
        if (c == 0) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        return false;
    }

    @Override
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }

    protected ConditionObject newCondition() {
        return new ConditionObject();
    }
}

自定义锁：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @description： 自定义锁
 * @author：weirx
 * @date：2022/1/13 14:05
 * @version：3.0
 */
public class MyLock implements Lock {

    MyLockSynchronizer myLockSynchronizer = new MyLockSynchronizer();

    @Override
    public void lock() {
        // 尝试获取锁，失败则加入等待队列
        myLockSynchronizer.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // 尝试获取锁，失败则加入等待队列, 可中断
        myLockSynchronizer.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        // 尝试获取锁，不加入等待队列
        return myLockSynchronizer.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // 尝试获取锁，不加入等待队列,有实现
        return myLockSynchronizer.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        // 释放锁
        myLockSynchronizer.release(1);
    }

    @Override
    public Condition newCondition() {
        // 条件变量
        return myLockSynchronizer.newCondition();
    }
}

测试锁的效果：

/**
 * @description： 测试
 * @author：weirx
 * @date：2022/1/13 14:24
 * @version：3.0
 */
public class TestMyLock {

    public static void main(String[] args) {
        MyLock myLock = new MyLock();

        new Thread(() -> {
            try {
                myLock.lock();
                System.out.println(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                        + " " + Thread.currentThread().getName() + " :acquire lock success");

                // 休眠一秒看效果
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                myLock.unlock();
                System.out.println(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                        + " " + Thread.currentThread().getName() + " :release lock success");
            }

        }, "t1").start();

        new Thread(() -> {
            try {
                myLock.lock();
                System.out.println(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                        + " " + Thread.currentThread().getName() + " :acquire lock success");
            } finally {
                myLock.unlock();
                System.out.println(DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")
                        + " " + Thread.currentThread().getName() + " :release lock success");
            }
        }, "t2").start();
    }
}

结果，ti一秒后释放锁，才会由t2获得锁：

2022-01-13 14:34:56 t1 :acquire lock success
2022-01-13 14:34:57 t2 :acquire lock success
2022-01-13 14:34:57 t1 :release lock success
2022-01-13 14:34:57 t2 :release lock success

测试下不可重入是否好使，只需要在上述测试代码的线程t1中，再次使用myLock.lock()获取一次锁，发现，整个程序被卡住了，只会打印一条信息：

2022-01-13 14:35:56 t1 :acquire lock success

四、关于Condition的补充

本篇没有介绍Condition的具体内容，但是在之前讲解ReentrantLock提到过【条件变量】，可以返回去看这篇文章了解其用法：https://www.jianshu.com/p/edec5185196d

源码学习真是难，看别人说的再多不如自己跟着走一遍，建议同学们参照本文自己跟踪一遍。

java并发编程（十七）带你了解什么是面试官常说的AQS

一、初识AQS

二、源码分析

2.1 Node源码剖析

2.2 ConditionObject源码剖析

2.3 锁的获取和释放

2.3.1 公平锁

2.3.2 非公平锁

2.3.3 Syc子类

3.3.4 acquire 和 release

2.4 简单总结

三、实践

四、关于Condition的补充

猜你喜欢

热点阅读

java并发编程（十七）带你了解什么是面试官常说的AQS

一、初识AQS

二、 源码分析

2.1 Node源码剖析

2.2 ConditionObject源码剖析

2.3 锁的获取和释放

2.3.1 公平锁

2.3.2 非公平锁

2.3.3 Syc子类

3.3.4 acquire 和 release

2.4 简单总结

三、实践

四、关于Condition的补充

猜你喜欢

热点阅读

二、源码分析