提升--09-1--AQS底层逻辑实现

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

文章目录

  • 一、怎么解释AQS是什么?
    • ==AQS的本质是JUC包下一个抽象类,AbstractQueuedSynchronizer (抽象的队列式同步器)==
  • 二、AQS核心底层和Lock是什么关系?
    • ReentrantLock的互斥锁功能就是基于AQS实现的。
    • 优先聊一下lock方法的区别。
    • 分析一下acquire方法中做了什么事
  • 三、AQS如何尝试获取资源?
    • 非公平锁的tryAcquire实现
    • 公平锁的实现
  • 四、AQS获取资源失败如何排队?
  • 五、AQS排队后如何重新尝试获取资源?
  • 六、AQS如何释放资源?


一、怎么解释AQS是什么?

AQS的本质是JUC包下一个抽象类,AbstractQueuedSynchronizer (抽象的队列式同步器)

  • AQS是JUC下的一个基础类,目的是为了提供一个共性的功能,让其他类去继承,比如ReentrantLock,CountDownLatch,Semaphore,ThreadPoolExecutor…………
    提升--09-1--AQS底层逻辑实现_第1张图片提升--09-1--AQS底层逻辑实现_第2张图片

二、AQS核心底层和Lock是什么关系?

ReentrantLock的互斥锁功能就是基于AQS实现的。

通过源码可以看到,ReentrantLock类并没有直接继承AQS,而是ReentrantLock的内部类Sync继承了AQS。

提升--09-1--AQS底层逻辑实现_第3张图片

Sync也是一个抽象类,他下面有两个实现。一个FairSync,一个NonfairSync。一个公平锁,一个非公平锁。

提升--09-1--AQS底层逻辑实现_第4张图片

提升--09-1--AQS底层逻辑实现_第5张图片
在ReentrantLock中,公平锁和非公平锁对于lock方法和tryAcquire方法的实现是不同的。

优先聊一下lock方法的区别。

// 非公平锁的lock方法
final void lock() {
    // 不管是否有线程在持有锁资源,直接尝试将state从0改为1,尝试拿锁。
    if (compareAndSetState(0, 1))
        // 拿锁成功了。将当前线程设置到exclusiveOwnerThread
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 前面抢锁失败走acquire
        acquire(1);
}

// 公平锁的lock方法
final void lock() {
    acquire(1);
}

分析一下acquire方法中做了什么事

// acquire方法实现
public final void acquire(int arg) {
    //1、tryAcquire方法:尝试获取锁资源的过程。拿到锁返回true,反之返回false。
    // 没拿到锁,才会走2和3。
    //2、addWaiter方法: 将当前没拿到锁的线程封装为Node,添加到同步队列。
    //3、acquireQueued方法: 长时间等待需要挂起线程,并且等到线程排到第一名时,
    //                      需要再次尝试获取锁资源
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

三、AQS如何尝试获取资源?

tryAcquire方法是如何尝试获取锁资源的,tryAcquire方法有两种实现,一种是公平,一种是非公平。

  • 判断state为0,那就根据情况抢锁
  • state不为0,但是当前线程持有锁,那就走锁重入的逻辑
  • 前面都不满足,告辞!

非公平锁的tryAcquire实现

// 非公平锁的实现。
final boolean nonfairTryAcquire(int acquires) {
    // 拿到当前线程。
    final Thread current = Thread.currentThread();
    // 获取state
    int c = getState();
    // 判断state是否为0
    if (c == 0) {
        // 当前没有线程持有锁。非公平锁直接尝试抢锁,抢成功就返回true
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 有线程持有锁。那就判断持有锁的线程是不是当前线程。
    else if (current == getExclusiveOwnerThread()) {
        // 到这说明是锁重入操作。
        // 将state + 1
        int nextc = c + acquires;
        // 判断+1之后,如果小于0,说明超过int正整数的取值范围了,无法再次重入~
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 将 + 1后的值赋值给state
        setState(nextc);
        // 返回true,锁重入成功~
        return true;
    }
    //没拿到锁,返回false
    return false;
}

公平锁的实现

// 公平锁的实现。
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 公平锁这里多了一行hasQueuedPredecessors()
        // 如果没有线程持有锁资源,优先查看是否有排队的线程
        // 1、如果没有线程排队,返回false,代表可以抢锁。
        // 2、如果有排队的,但是当前线程排在“第一名”,返回false,代表可以抢锁。
        // 3、如果有排队的,但是当前线程没有排在“第一名”,返回true,代表不可以抢锁。
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;a
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

四、AQS获取资源失败如何排队?

如果获取锁资源失败,会执行addWaiter方法,去做排队操作。

  1. 将当前线程封装Node。
  2. 如果同步队列为null,需要优先初始化一个虚拟的Node节点
  3. 将当前Node添加到tail的后面。
private Node addWaiter(Node mode) {
    // 将当前线程封装Node
    Node node = new Node(Thread.currentThread(), mode);
    // 拿到尾结点
    Node pred = tail;
    // 不为null,代表现在有Node对象。
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果pred是null,
    enq(node);
    return node;
}
// 将node添加到同步队列
private Node enq(final Node node) {
    // 死循环是为了确保一定能添加成功
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            // 初始化一个没有线程信息的Node,作为头尾
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

五、AQS排队后如何重新尝试获取资源?

  • 挂起需要确保prev节点的状态为-1。
  • 重新获取锁资源需要确保当前node是head.next,并且基于tryAcquire去获取锁资源。
// 排队后的挂起操作和获取锁资源的操作
// node就是刚刚去排队的Node
final boolean acquireQueued(final Node node, int arg) {
    // 拿锁失败了么??true
    boolean failed = true;
    try {
        // 死循环,拿到锁才能走!!
        for (;;) {
            // 拿到当前Node的上一个Node
            final Node p = node.prev;
            // 只有head.next的node才有资格抢锁
            if (p == head && tryAcquire(arg)) {
                // 说明拿到锁资源了。
                // 当前node成为新的head,线程和prev都设置为null
                setHead(node);
                p.next = null; 
                failed = false;
                // 拿到成功,返回中断标记位(这里省略了这部分代码)
                return false;
            }
            // 没资格拿,或者没拿到!
            // 需要优先掌握一个知识,Node中有一个waitStatus的状态
            // 1:代表当前Node取消了,不排了,告辞,走人。
            // 0:代表默认状态,啥事没有~
            // -1:代表当前Node的next节点可能挂起了。
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 基于Unsafe类的park方法,将当前线程挂起!
                parkAndCheckInterrupt())
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // pred是prev
    // node是curr
    // 拿到上一个Node的状态
    int ws = pred.waitStatus;
    // 如果上一个Node状态是-1,返回true,代表可以挂起
    if (ws == Node.SIGNAL)
        return true;

    // 上一个节点状态是否是取消状态
    if (ws == 1) {
        // 绕过状态为1的节点,找到一个状态正常的。
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus == 1);
        pred.next = node;
    } else {
        // 如果上一个节点状态正常,直接修改为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

六、AQS如何释放资源?

  • 加锁是执行lock,释放锁资源玩的是unlock方法。
  • 释放锁会对state做-1操作,如果-1后state为0,代表释放锁资源成功。
  • 如果锁资源释放成功,需要查看head状态是否为-1,如果为-1需要唤醒离head最近的有效节点。
// 释放锁资源
public final boolean release(int arg) {
    // 执行tryAcquire释放锁资源
    if (tryRelease(arg)) {
        // 释放干净了!
        // 先拿head
        Node h = head;
        // 如果head不为null,head的状态是否为 -1
        if (h != null && h.waitStatus == -1)
            // 唤醒后面挂起的线程(睡觉的线程)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
// 释放锁操作。
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    // 释放锁资源的线程必须是持有锁资源的线程,否则甩你一个异常。
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // free代表锁释放干净了么?
    boolean free = false;
    // 如果state为0,代表锁资源释放干净了
    // 没进if,就代表没释放干净
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }

    setState(c);
    return free;
}

// 唤醒后续挂起的线程   node是head
private void unparkSuccessor(Node node) {
    // 拿到head的状态
    int ws = node.waitStatus;
    // 状态是-1,归位0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // s可能就是要被唤醒的线程
    Node s = node.next;
    // 如果s节点出现了问题,不排队了,那就找离head最近的有效节点唤醒!
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 会从tail开始往前找,找到离head最近的有效节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 如果s不为null,代表找到了具体要唤醒的Node
    if (s != null)
        // 唤醒对应的线程
        LockSupport.upnark(s.thread);
}

你可能感兴趣的:(多线程高并发,java)