12、AQS(AbstractQueuedSynchronizer)详解

最新推荐文章于 2024-09-25 11:06:23 发布

郭吱吱

最新推荐文章于 2024-09-25 11:06:23 发布

阅读量206

点赞数 1

分类专栏： JUC并发文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/pingfanxiansheng/article/details/126530254

版权

JUC并发专栏收录该内容

14 篇文章 0 订阅

订阅专栏

4、AQS源码深度讲解和分析（ReentrantLock()为例）

4.1 ReentrantLock公平锁与非公平锁

4.1.1 非公平与公平锁lock()方法的区别

4.2 AQS acquire(int arg)方法三大流程走向

5、流程源码解析（非公平锁为例子-以例子流程解读代码）

5.0 第一个顾客抢占——lock()方法[A顾客]

5.1 第二个顾客抢占——lock()方法[B顾客]

5.2 实现类的(ReentrantLock) tryAcquire(int acquires)方法[B顾客]

5.3 AQS addWaiter(Node)方法[B顾客]

5.4 实现类的(ReentrantLock) tryAcquire(int acquires)方法[C顾客]

5.5 AQS addWaiter(Node)方法[C顾客]

5.6 acquireQueued(addWaiter(Node.EXCLUSIVE), arg) 方法[B顾客]

5.7 parkAndCheckInterrupt() 方法[B顾客]

5.8 [C顾客]和[B顾客]从5.6~5.8一致

5.9 [A顾客]释放锁——unlock()方法

5.10 cancelAcquire(node) 取消

1、前置知识要求

1、公平锁和非公平锁

2、可重入锁

3、自旋思想

4、LockSupport

5、数据结构之双向链表

6、设计模式之模板设计模式

2、AQS入门级别理论知识

2.1 是什么

抽象的队列同步器

是用来实现锁或者其它同步器组件的公共基础部分的抽象实现，是重量级基础框架及整个JUC体系的基石，主要用于解决锁分配给谁的问题；

整体就是一个抽象的FIFO(first-in-first-out)队列来完成资源获取线程的排队工作，并通过一个int类变量表示持有锁的状态。

2.2 AQS为什么是JUC框架基础

以下类都依赖于AQS框架

2.3 锁和同步器的关系？

锁面向的是使用者(程序员)。

同步器，面向锁的实现者：Java并发大神DougLee，提出统一规范并简化了锁的实现，将其抽象出来，屏蔽了同步状态管理，同步队列的管理和维护，阻塞线程排队和通知、唤醒机制等；是一切锁和同步组件实现的——公共基础部分。

2.4 AQS可以干什么

抢到资源的线程直接使用处理业务，抢不到资源的必然设计一种排队等候机制。抢占资源失败的线程继续去等待（类似银行业务办理窗口都满了，暂时没有受理窗口的顾客只能去候客区排队等候），但等候线程仍然保留获取锁的可能且获取锁流程仍在继续（候客区的顾客也在等着叫号，轮到了再去受理窗口办理业务）。

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

3、AQS源码分析前置知识

3.1 AQS内部体系架构

3.2 AQS自身

3.3 AQS内部Node节点

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;
    /** 等待condition唤醒 */
    static final int CONDITION = -2;
    /**
     * 共享式同步状态获取将会无条件的传播下去
     * unconditionally propagate
     */
    static final int PROPAGATE = -3;

    /**
     * 线程等待状态：初始值为0。其他值为上述几种状态
     */
    volatile int waitStatus;

    /**
     * 前置节点
     */
    volatile Node prev;

    /**
     * 后置节点
     */
    volatile Node next;

    /**
     * 当前线程
     */
    volatile Thread thread;

    /**
     * 表示该节点模式(是独占还是共享)
     */
    Node nextWaiter;

    /**
     * 是否是共享模式
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    /**
     * 返回前置节点
     * @return the predecessor of this node
     */
    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;
    }
}

4、AQS源码深度讲解和分析（ReentrantLock()为例）

4.1 ReentrantLock公平锁与非公平锁

4.1.1 非公平与公平锁lock()方法的区别

都调用了acquire(1)方法

我们发现该方法时AQS中的方法，但是AQS中的tryAcquire方法是一个没有具体实现的方法，需要子类自己去实现（这个也就是设计模式中的模板设计模式）

唯一区别公平锁判断是否有排队线程

         对比公平锁和非公平锁的tryAcquire()方法的实现代码，其实差别就在于非公平锁获取时比公平锁中少了一个判断!hasQueuedPredecessors()。

hasQueuedPredecessors()中判断了是否需要排队，导致公平锁和非公平锁的差异如下：

        公平锁：公平锁先来先得，线程获取锁时，如果这个锁的等待队列中已经有线程在等待，那么当前线程就会进入等待队列中；

        非公平锁：不管是否有等待队列，都先抢占一下锁，如果获取到锁，则立刻占有锁对象；如果没有抢占到锁，则回到队尾排队。也就是说队列的第一个排队线程苏醒后，不一定就是派头线程获得锁，它还需要参加锁的竞争。

4.2 AQS acquire(int arg)方法三大流程走向

5、流程源码解析（非公平锁为例子-以例子流程解读代码）

例如A、B、C三个顾客，去银行办理业务，A先到，此时窗口空无一人。

public static void main(String[] args) {
    ReentrantLock lock = new ReentrantLock();

    // A严重耗时，长期占有窗口
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println("----come in A");
            try {
                TimeUnit.MINUTES.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }finally {
            lock.unlock();
        }
    },"A").start();

    // B顾客是第二个顾客,A占有窗口,去等候区等待,进入AQS队列
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println("----come in B");
        }finally {
            lock.unlock();
        }
    },"B").start();
    // C顾客是第三个顾客,A占有窗口,去等候区等待,进入AQS队列
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println("----come in C");
        }finally {
            lock.unlock();
        }
    },"C").start();
}

本来AQS原始状态

5.0 第一个顾客抢占——lock()方法[A顾客]

final void lock() {
    // 抢占公共资源state，试图将状态0改为1
    if (compareAndSetState(0, 1))
        // 如果抢占成功，将占有线程设置为当前线程(A顾客线程)
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

5.1 第二个顾客抢占——lock()方法[B顾客]

final void lock() {
    // 顾客B尝试获取锁，肯定失败，因为顾客A再占有
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 顾客B进入该方法
        acquire(1);
}

找到子类实现的方法

5.2 实现类的(ReentrantLock) tryAcquire(int acquires)方法[B顾客]

final boolean nonfairTryAcquire(int acquires) {
    // 得到顾客B线程
    final Thread current = Thread.currentThread();
    // 现在资源类中的state值为1
    int c = getState();
    // 如果state状态位为0的话，下面会尝试获取锁；但是目前B线程是不符合该条件
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 当前线程是否等于当前持有资源线程(这里就是可重入锁的实现情况)
    // 但是当前线程为A顾客，所以说不等于B顾客
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    // B线程尝试抢锁所败
    return false;
}

public final void acquire(int arg) {
    // 上步tryAcquire(arg)返回false 取反之后继续下一步操作：addWaiter(Node.EXCLUSIVE)
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

5.3 AQS addWaiter(Node)方法[B顾客]

为当前线程和给定模式创建并排队节点

/**
 * 为当前线程和给定模式创建并排队节点
 * Creates and enqueues node for current thread and given mode.
 *
 * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
 * @return the new node
 */
private Node addWaiter(Node mode) {
    // 将B顾客封装撑node节点
    Node node = new Node(Thread.currentThread(), mode);
    // 获取到尾指针
    Node pred = tail;
    // 尾指针等于null,这里不会进入到if中(别着急，后面C顾客会走到)
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 进入该方法
    enq(node);
    return node;
}

AQS中的方法 enq(final Node node)：将节点插入队列

private Node enq(final Node node) {
    // 第一次循环(不考虑CAS失败问题)
    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;
            }
        }
    }
}

第二次循环

private Node enq(final Node node) {
    // 第二次循环
    for (;;) {
        // 获取尾节点（上图可以看出是上次循环新建出来的虚拟节点）
        Node t = tail;
        // 进入不到该if中，将进入else
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 将当前B顾客的前置节点设置成上次尾节点的对象
            node.prev = t;
            // 将尾节点设置成当前节点
            if (compareAndSetTail(t, node)) {
                // 将老的尾节点的后置节点设置成B顾客节点
                t.next = node;
                return t;
            }
        }
    }
}