【Java并发】AQS四:AbstractQueuedSynchronizer内部方法分类详细

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_22871607/article/details/89402680

AbstractQueuedSynchronizer作为一个同步的基础框架,里面封装了很多的方法,通过对state值的定义处理,以及排队机制来实现同步机制。

一:state值定义

核心state状态值,通过对其的设置获取来判断是否有资格进入同步锁定资源

	/**
     * 等待队列的头,延迟初始化。除了初始化之外,它只通过setHead方法进行修改。注意:如果head存在,则保证它的等待状态不会被取消。
     */
    private transient volatile Node head;
    /**
     * 等待队列的尾部,延迟初始化。仅通过方法enq()修改以添加新的等待节点。
     */
    private transient volatile Node tail;
    /**
     * 同步状态。核心部分,根据其值来判定同步状态
     */
    private volatile int state;
    /**
     * 返回同步状态的当前值。该操作具有{@code volatile}读取的内存语义,即内存可见性、禁止重排序
     */
    protected final int getState() {
        return state;
    }
    /**
     * 设置同步状态的值。这个操作具有{@code volatile}写的内存语义。
     */
    protected final void setState(int newState) {
        state = newState;
    }
    /**
     * 如果当前状态值等于期望值,则自动将同步状态设置为给定的更新值。该操作具有{@code volatile}读写的内存语义。
     */
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

二:内部排队公用方法

内部排队公用方法,供AQS内部之间使用

	// 自旋机制提供的自旋纳秒数,提高响应能力
    static final long spinForTimeoutThreshold = 1000L;
    // 往队列里面加入一个节点
    private Node enq(final Node node)
    // 根据给定模式(共享/排他)创建或加入队列
    private Node addWaiter(Node mode)
    // 设置头节点
    private void setHead(Node node)
    // 唤醒继承节点线程
    private void unparkSuccessor(Node node)
    // 共享模型下是否共享值
    private void doReleaseShared()
    // 设置队列的头部,并检查后续队列是否可以在共享模式下等待,如果设置了propagate > 0或propagate status,则将进行传播。
    private void setHeadAndPropagate(Node node, int propagate)

三:各种版本获取的实用程序

// 取消尝试 acquire 操作
private void cancelAcquire(Node node)
// 检查和更新未能获取的节点的状态。如果线程阻塞,返回true。这是所有采集回路的主要信号控制。需要pred == node.prev。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node)
// 中断当前线程方法
static void selfInterrupt()
// 阻塞当前线程,然后检查当前线程是否中断
private final boolean parkAndCheckInterrupt()

获取的不同风格,在独占/共享和控制模式中有所不同。每一种都大同小异,但却令人讨厌地不同。由于异常机制(包括确保我们在尝试获取抛出异常时取消)和其他控件之间的交互,只有少量的因式分解是可能的,至少不会对性能造成太大影响。

// 获取队列中已存在线程的独占不可中断模式。用于条件等待方法以及获取。
final boolean acquireQueued(final Node node, int arg)
// 以独占中断模式获取。
private void doAcquireInterruptibly(int arg)
// 以独占时间模式获取。
private boolean doAcquireNanos(int arg, long nanosTimeout)
// 以共享不可中断模式获取。
private void doAcquireShared(int arg)
// 以共享中断模式获取。
private void doAcquireSharedInterruptibly(int arg)
// 以共享时间模式获取。
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)

四:对外公开方法

此类方法用于 子类在实现该AQS基础框架时,需要根据自定义的共享或排他模式,进行实现的公开对外方法。

首先,供子类继承AQS自定义实现同步机制(共享/排他)的方法,总共就5个方法:

// 试图以独占模式获取。这个方法应该查询对象的状态是否允许以独占模式获取它,如果允许,也应该查询是否允许以独占模式获取它。
// 执行获取的线程总是调用此方法。如果此方法报告失败,如果尚未排队,则获取方法可以对线程进行排队,直到从其他线程发出释放信号。
// 这可以用来实现方法{@link Lock#tryLock()}。
// 参数 arg 这个值总是传递给获取方法的值,或者是在进入条件wait时保存的值
// 如果获取将使此同步器处于非法状态。必须以一致的方式抛出此异常,以便同步工作正常。
protected boolean tryAcquire(int arg)
// 试图将状态设置为以独占模式反映发布。此方法始终由执行发布的线程调用。
protected boolean tryRelease(int arg)
// 共享模式下获得状态值
protected int tryAcquireShared(int arg)
// 共享模式下释放状态值
protected boolean tryReleaseShared(int arg)
// 如果同步仅针对当前(调用)线程执行,则返回{@code true}。此方法在每次调用非等待的{@link ConditionObject}方法时调用。
// (相反,等待方法调用{@link #release}。) 此方法仅在{@link ConditionObject}方法内部调用,因此如果不使用条件,则不需要定义该方法。
protected boolean isHeldExclusively()

其次,实现AQS的子类,在使用时,供外部使用的方法:

// 以独占模式获取,忽略中断。通过至少调用一次{@link #tryAcquire}来实现,成功后返回。否则,线程将排队,
// 可能会反复阻塞和解除阻塞,调用{@link #tryAcquire}直到成功。此方法可用于实现方法{@link Lock# Lock}。
public final void acquire(int arg)
// 以独占模式获取,如果中断将中止。首先检查中断状态,然后至少调用一次{@link #tryAcquire},成功后返回。否则,
// 线程将排队,可能反复阻塞和解除阻塞,调用{@link #tryAcquire},直到成功或线程被中断。此方法可用于实现方法{@link Lock#lockInterruptibly}。
public final void acquireInterruptibly(int arg)
// 在指定时间内,一直获取,排他模式
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
// 以独占模式发布。如果{@link #tryRelease}返回true,则通过解阻塞一个或多个线程来实现。此方法可用于实现方法{@link Lock#unlock}。
public final boolean release(int arg)
// 共享模式下获取
public final void acquireShared(int arg)
// 以共享模式获取,如果中断将中止。首先检查中断状态,然后至少调用一次{@link # tryacquiremred},成功后返回。
// 否则,线程将排队,可能反复阻塞和解除阻塞,调用{@link # tryacquiremred},直到成功或线程被中断。
public final void acquireSharedInterruptibly(int arg)
// 在指定时间内,一直获取,共享模式
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
// 释放共享锁
public final boolean releaseShared(int arg)

跟着acquire()的源码:

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
  1. tryAcquire(arg) : 需要用于自定义同步机制集成AQS实现的类,主要实现思路是判断state状态是否可用,可用就获取它,并且state值加arg
  2. addWaiter(Node.EXCLUSIVE) :创建排他模式队列,并把当前线程作为节点加入到队列尾部。
  3. acquireQueued(node, arg) :
    先获得同步资源,如果获取同步资源失败,则通过自旋锁自旋转获取前驱线程节点,并继续尝试获得同步资源直到前驱节点为头节点,且获取同步资源成功,
    则设置当前线程node节点为头节点,跳出自旋锁返回,如果整个过程发生中断返回true,否则返回false
  4. selfInterrupt(); 当获取失败时,且自旋获取期间发生中断,进行一次自我中断

查看release()源码:

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

1、tryRelease(arg):需要自定义同步机制继承AQS时,实现的方法,通过释放资源值,即state - args
2、unparkSuccessor(h):唤醒头节点的后续节点

五:队列检查方法

// 查询是否有线程正在等待获取。注意,由于中断和超时导致的取消可能随时发生,返回true并不保证任何其他线程将获得。
public final boolean hasQueuedThreads()
// 查询是否有线程争用过此同步器;也就是说是否获取方法曾经被阻塞。
public final boolean hasContended()
// 返回队列中的第一个(等待时间最长的)线程,如果当前没有线程排队,则返回{@code null}
// 在此实现中,此操作通常以常数时间返回,但如果其他线程同时修改队列,则可能在争用时迭代。
public final Thread getFirstQueuedThread()
// 判断给定的线程是否在排队
public final boolean isQueued(Thread thread)
// 如果第一个排队的线程(如果存在)正在以排它模式等待,则返回{@code true}。如果这个方法返回{@code true},并且当
// 前线程正在尝试以共享模式获取(也就是说,这个方法是从{@link # tryacquiremred}调用的),那么可以保证当前线程不是第
// 一个排队的线程。仅在ReentrantReadWriteLock中作为启发式使用。
final boolean apparentlyFirstQueuedIsExclusive()
// 查询是否有任何线程等待获取的时间超过当前线程。该方法是设计用于一个公平的同步器.
public final boolean hasQueuedPredecessors()

六:测量和监控队列的方法

// 返回等待获取的线程数的估计值。这个值只是一个估计值,因为当这个方法遍历内部数据结构时,线程的数量可能会动态变化。该方法用于监控系统状态,不用于同步控制。
public final int getQueueLength() 
// 返回一个集合,其中包含可能正在等待获取的线程,仅为预估值
public final Collection<Thread> getQueuedThreads()
// 和getQueuedThreads一样,但是这个方法返回的只是独占模式下排队线程数
public final Collection<Thread> getExclusiveQueuedThreads()
// 和getQueuedThreads一样,但是这个方法返回的只是共享模式下排队线程数
public final Collection<Thread> getSharedQueuedThreads()

七:条件的内部支持方法

// 如果一个节点(始终是最初放置在条件队列中的节点)现在正等待在同步队列上重新获取,则返回true。
final boolean isOnSyncQueue(Node node)\
// 如果节点位于同步队列上,则通过从tail向后搜索返回true。仅在isOnSyncQueue需要时调用。
private boolean findNodeFromTail(Node node)
// 将节点从条件队列传输到同步队列。如果成功返回true。
final boolean transferForSignal(Node node)
// 如果需要,在取消等待后传输节点来同步队列。如果线程在发出信号之前被取消,则返回true。
final boolean transferAfterCancelledWait(Node node)
// 使用当前状态值调用release;返回保存的状态。取消节点并在失败时抛出异常。
final int fullyRelease(Node node)

八:条件测量方法

// 查询给定条件对象是否使用此同步器作为其锁。
public final boolean owns(ConditionObject condition)
// 查询是否有线程正在等待与此同步器关联的给定条件。注意,
// 由于超时和中断可能随时发生,{@code true}返回并不保证将来的{@code信号}将唤醒任何线程。该方法主要用于系统状态监测。
public final boolean hasWaiters(ConditionObject condition)
// 返回等待的线程数的估计值,该方法适用于对某型水电站的监测系统状态,不用于同步控制。
public final int getWaitQueueLength(ConditionObject condition)
// 根据条件获取等待的线程
public final Collection<Thread> getWaitingThreads(ConditionObject condition) 
//  一些Unsafe底层方法操作,保证CAS的正确性
private static final Unsafe unsafe = Unsafe.getUnsafe();
....
....
....

总结:比较常用的是第四类方法,对外公开方法,形如ReentrantLock,Semaphore,CountDownLatch都是实现此框架,里的对外公开方法。当然根据AQS我们也可以定义属于我们自己的同步机制

展开阅读全文

没有更多推荐了,返回首页