java并发包工具CountDownLatch源码分析

目录
  • 一:简述
  • 二:什么是CountDownLatch
  • 三:CountDownLatch的使用
  • 四:CountDownLatch原理分析
    • 构造函数
    • await()方法:
    • doAcquireSharedInterruptibly()
      • 1. 当前节点的前置节点是head节点
      • 2. 当前节点的前置节点不是head节点
    • addWaiter()
    • setHeadAndPropagate()
    • shouldParkAfterFailedAcquire()
    • parkAndCheckInterrupt()
    • countDown()
    • doReleaseShared()
    • unparkSuccessor()
  • 五:最后

一:简述

本篇文章对java并发包工具CountDownLatch进行介绍,并且通过对CountDownLatch源码的分析来加深对CountDownLatch的理解。

二:什么是CountDownLatch

CountDownLatch是java并发包中提供的一个工具类,CountDownLatch的作用很简单,它可以让一个或者一组线程在开始执行操作之前,必须要等到其他线程执行完才执行,它是基于AQS的共享锁来实现的。

三:CountDownLatch的使用

简单介绍下CountDownLatch的使用

CountDownLatch的主要方法有三个:

1.构造函数

2.countDown()

3.await()

简单给大家写一个demo:

public class TestThread {
     static CountDownLatch countDownLatch = new CountDownLatch(2);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println("线程等待");
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程C被唤醒");
        },"线程C").start();
        new Thread(()->{
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("计数器减1");
            countDownLatch.countDown();
        },"线程A").start();
        new Thread(()->{
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("计数器减1");
            countDownLatch.countDown();
        },"线程B").start();
        countDownLatch.await();
        System.out.println("主线程被唤醒");
    }
}

线程C和主线程调用await()方法后会进行阻塞,直到线程A和线程B调用countdown()方法将计数值减为0之后才会继续执行。

输出结果:

四:CountDownLatch原理分析

前面两个小节是为了帮助不知道没使用过CountDownLatch的同学。那么接下来进入正题,对CountDownLatch的原理分析。我们将以CountDownLatch的构造函数,countDown(),await()三个方法对CountDownLatch的源码进行解析。

构造函数

CountDownLatch只有一个有参的构造函数,我们需要传递一个大于0的整数,构造函数会初始化一个Sync的实例,而Sync正是继承了AbstractQueuedSynchronizer(简称AQS)。Sync初始化的时候会将我们设置的整数传递给AQS的成员变量state。

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        Sync(int count) {
            setState(count);
        }
}
    protected final void setState(int newState) {
        state = newState;
    }

接下来我们看await()方法

await()方法:

流程图:

源码分析:

首先线程调用await()方法后会去判断当前state是否大于0,如果不是大于0,那么直接就返回继续执行业务代码,如果大于0,那么就会调用doAcquireSharedInterruptibly()。所以重点是doAcquireSharedInterruptibly()方法。

public void await() throws InterruptedException {
        //调用Sync的acquireSharedInterruptibly()方法
        sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        //判断当前的state的值是否等于0 如果等于0返回1 否则返回-1
        if (tryAcquireShared(arg) < 0)
            // 如果state等于0 那么什么都不做 直接返回,如果大于0 就执行doAcquireSharedInterruptibly()
            doAcquireSharedInterruptibly(arg);
    }
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

await()方法的核心在于doAcquireSharedInterruptibly()方法,所以接下来我们重点分析doAcquireSharedInterruptibly()方法。

doAcquireSharedInterruptibly()

首先通过addWaiter()方法将当前线程封装成一个类型为SHARED的Node节点,然后判断当前节点的前一个节点是否是head节点,分为两种情况:

1. 当前节点的前置节点是head节点

那么就会再次调用tryAcquireShared()判断一下state的值是等于0,又分为两种情况

a. state如果等于0

那么就调用setHeadAndPropagate()方法将当前节点设置为头节点,并且调用唤醒下一个状态不为CANCELLED的节点。

b. 如果state不等于0

那么就调用shouldParkAfterFailedAcquire()方法将前一个节点的状态修改为SIGNAL,并且调用parkAndCheckInterrupt()方法将当前线程阻塞起来。

2. 当前节点的前置节点不是head节点

那么就掉用shouldParkAfterFailedAcquire()方法将前一个节点的状态修改为SIGNAL,并且调用parkAndCheckInterrupt()方法将当前线程阻塞起来。

(需要注意的是线程被唤醒之后继续执行这里的代码)

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        //调用addWaiter()方法将线程封装成Node并且放入到AQS队列的尾部
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                //获取当前节点的前一个节点
                final Node p = node.predecessor();
                //如果前一个节点是head节点
                if (p == head) {
                    //再次判断state的值是否为0
                    int r = tryAcquireShared(arg);
                    // tryAcquireShared()返回1代表state为0
                    if (r >= 0) {
                        //将当前节点设置为头节点 并且唤醒下一个正常的节点
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                //shouldParkAfterFailedAcquire()方法将当前节点的前一个节点的状态设置为SIGNAL,
                //parkAndCheckInterrupt()方法将当前线程阻塞
                //线程被唤醒之后继续从这里开始执行
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

addWaiter()

addWaiter()作用是将当前线程封装成Node节点,并且加入到AQS队列中。

private Node addWaiter(Node mode) {
	//将没有获得锁的线程封装成一个node
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
	//如果AQS尾结点不为null 代表AQS链表已经初始化 尝试将构建好的节点添加到链表的尾部
        if (pred != null) {
            node.prev = pred;
	    //cas替换AQS的尾结点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
	//没有初始化调用enq()方法
        enq(node);
        return node;
    }
private Node enq(final Node node) {
	    //自旋
        for (;;) {
            Node t = tail;
	    //尾结点为空 说明AQS链表还没有初始化 那么进行初始化
            if (t == null) { // Must initialize
	    //cas 将AQS的head节点 初始化 成功初始化head之后,将尾结点也初始化
            //注意 这里我们可以看到head节点是不存储线程信息的 也就是说head节点相当于是一个虚拟节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
		//尾结点不为空 那么直接添加到链表的尾部即可
                //加入链表的时候先指定prev 然后cas成功 再指定next
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

setHeadAndPropagate()

setHeadAndPropagate()的作用就是将当前节点设置为头结点,并且调用doReleaseShared()方法唤醒当前节点的下一个正常节点。doReleaseShared()方法我们在下面分析countDown()方法的时候在进行仔细的分析。

 private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        //将当前节点设置为头结点
        setHead(node);
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                //唤醒头结点的下一个节点
                //其实也就是当前节点的下一个节点,因为前面已经将当前节点设置为新的头结点了
                doReleaseShared();
        }
    }

shouldParkAfterFailedAcquire()

shouldParkAfterFailedAcquire()方法会将传入的节点(传进来的是当前节点的前置节点)的状态设置为SIGNAL状态。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
	    //如果节点是SIGNAL状态 不需要处理 直接返回
            return true;
        if (ws > 0) {
	   //如果节点状态>0 说明节点是取消状态 这种状态的节点需要被清除 用do while循环顺便清除一下前面的连续的、状态为取消的节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
	    //正常的情况下 利用cas将前一个节点的状态替换为 SIGNAL状态 也就是-1
	    //注意 这样队列中节点的状态 除了最后一个都是-1 包括head节点
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

parkAndCheckInterrupt()

parkAndCheckInterrupt()方法的作用就是调用 LockSupport.park()方法将线程阻塞,并且返回线程的中断标志。

private final boolean parkAndCheckInterrupt() {
  //挂起当前线程 并且返回中断标志  LockSupport.park(thread) 会调用UNSAFE.park()方法将线程阻塞起来(是一个native方法)
        LockSupport.park(this);
        return Thread.interrupted();
}

到这里await()方法也就分析完了 接下来我们分析countDown()方法

countDown()

流程图:

源码:

countDown()方法首先查看state的值是否是0,分为两种情况

1. 如果state为0

说明没有线程需要被唤醒,那么直接返回。

2. 如果state不为0

那么将利用cas将state的值减1,判断新的state是否为0 ,如果不为0,说明还不能唤醒阻塞的线程,直接返回,如果新的state为0,那么调用doReleaseShared()方法唤醒阻塞的线程。

public void countDown() {
   sync.releaseShared(1);
}
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            //自旋+cas保证线程安全
            for (;;) {
                //获取state的值
                int c = getState();
                //如果state为0 说明没有需要唤醒的线程 直接返回
                if (c == 0)
                    return false;
                int nextc = c-1;
                //利用cas将state减一 如果新的state为0 说明需要唤醒阻塞的线程,否则不需要唤醒
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

countDown()方法核心是doReleaseShared()方法 所以我们重点分析doReleaseShared()。

doReleaseShared()

    private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                //如果头结点的状态是SIGNAL
                if (ws == Node.SIGNAL) {
                    //cas修改节点的状态为0 失败的话继续自旋
                    // 成功的话调用unparkSuccessor唤醒头结点的下一个正常节点
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                //如果节点状态为0 那么cas替换为PROPAGATE 失败进入下一次自旋
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

unparkSuccessor()

unparkSuccessor()方法的作用是唤醒头节点后第一个不为null且状态不为cancelled的节点。

private void unparkSuccessor(Node node) {
        //获取头结点的状态 将头结点状态设置为0 代表现在正在有线程被唤醒 如果head状态为0 就不会进入这个方法了
        int ws = node.waitStatus;
        if (ws < 0)
            //将头结点状态设置为0
            compareAndSetWaitStatus(node, ws, 0);
	//唤醒头结点的下一个状态不是cancelled的节点 (因为头结点是不存储阻塞线程的)
        Node s = node.next;
	//当前节点是null 或者是cancelled状态
        if (s == null || s.waitStatus > 0) {
            s = null;
	 //从aqs链表的尾部开始遍历 找到离头结点最近的 不为空的 状态不是cancelled的节点 赋值给s
         //这里为什么从尾结点开始遍历而不是头结点 是因为添加结点的时候是先初始化结点的prev的, 从尾结点开始遍历 不会出现prve没有赋值的情况
         //如果从头结点进行遍历 next为null 并不能保证链表遍历完了
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
	    //调用LockSupport.unpark()唤醒指定的线程
            LockSupport.unpark(s.thread);
    }

线程被唤醒之后,我们需要回到线程阻塞的地方继续分析线程被唤醒之后的操作。

前文我们分析await()方法之后已经知道了线程阻塞在doAcquireSharedInterruptibly()方法中。如果线程没有被中断过,会判断state的值,这里线程是被调用countDown方法唤醒的,所以state一定是0,所以会调用setHeadAndPropagate()方法更新头结点并继续唤醒之后的线程。这样就会把依次将所有阻塞的阻塞线程都唤醒。(因为countDownLatch的计数器为0之后需要将所有调用await()阻塞的线程唤醒)

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            //
            for (;;) {
                //获取当前节点的前一个节点
                final Node p = node.predecessor();
                //如果前一个节点是head节点
                if (p == head) {
                    //再次判断state的值是否为0
                    int r = tryAcquireShared(arg);
                    // tryAcquireShared()返回1代表state为0
                    if (r >= 0) {
                        //将当前节点设置为头节点 并且唤醒下一个正常的节点
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                //线程被唤醒之后继续从这里开始执行 如果线程没有被中断过 会进入都下次for循环
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

五:最后

本篇文章主要介绍了CountDownLatch的使用并且通过分析其源码对CountDownLatch的原理进行了分析。

注:其实像addWaiter(),unparkSuccessor(),shouldParkAfterFailedAcquire()等一些AQS公用的方法在我的另外一篇文章里分析过,原文地址:ReentrantLock源码分析

更多关于java并发包CountDownLatch的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java中CyclicBarrier和CountDownLatch的用法与区别

    目录 前言 CountDownLatch 例子 CyclicBarrier 构造函数 例子 两者区别 前言 CyclicBarrier和CountDownLatch这两个工具都是在java.util.concurrent包下,并且平时很多场景都会使用到. 本文将会对两者进行分析,记录他们的用法和区别. CountDownLatch CountDownLatch是一个非常实用的多线程控制工具类,称之为"倒计时器",它允许一个或多个线程一直等待,直到其他线程的操作执行完后再执行. Coun

  • Java多线程之同步工具类CountDownLatch

    前言: CountDownLatch是一个同步工具类,它允许一个或多个线程一直等待,直到其他线程执行完后再执行.例如,应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行. 1 CountDownLatch主要方法 void await():如果当前count大于0,当前线程将会wait,直到count等于0或者中断. PS:当count等于0的时候,再去调用await() , 线程将不会阻塞,而是立即运行.后面可以通过源码分析得到. boolean await(long t

  • java多线程CountDownLatch与线程池ThreadPoolExecutor/ExecutorService案例

    1.CountDownLatch: 一个同步工具类,它允许一个或多个线程一直等待,直到其他线程的操作执行完后再执行. 2.ThreadPoolExecutor/ExecutorService: 线程池,使用线程池可以复用线程,降低频繁创建线程造成的性能消耗,同时对线程的创建.启动.停止.销毁等操作更简便. 3.使用场景举例: 年末公司组织团建,要求每一位员工周六上午8点到公司门口集合,统一乘坐公司所租大巴前往目的地. 在这个案例中,公司作为主线程,员工作为子线程. 4.代码示例: package

  • java并发使用CountDownLatch在生产环境翻车剖析

    目录 前言 需求背景 具体实现 解决方案 总结 前言 大家好,我是小郭,之前分享了CountDownLatch的使用,我们知道用来控制并发流程的同步工具,主要的作用是为了等待多个线程同时完成任务后,在进行主线程任务. 万万没想到,在生产环境中竟然翻车了,因为没有考虑到一些场景,导致了CountDownLatch出现了问题,接下来来分享一下由于CountDownLatch导致的问题. [线程]并发流程控制的同步工具-CountDownLatch 需求背景 先简单介绍下业务场景,针对用户批量下载的文

  • java线程并发控制同步工具CountDownLatch

    目录 前言 了解CountDownLatch 思考问题: 主要参数与方法 构造方法 CountDownLatch底层实现原理 执行流程图 实践 用法一: 用法二: 总结 前言 大家好,我是小郭,前面我们学习了利用Semaphore来防止多线程同时操作一个资源,通常我们都会利用并行来优化性能,但是对于串行化的业务,可能需要按顺序执行,那我们怎么才能处理呢?今天我们来学习另一个并发流程控制的同步工具CountDownLatch. 了解CountDownLatch 首先,CountDownLatch是

  • Java实现限定时间CountDownLatch并行场景

    目录 业务场景: 解决方案: 总结 业务场景: 一个用户数据接口,要求在20ms内返回数据,它的调用逻辑复杂,关联接口多,需要从3个接口汇总数据,这些汇总接口最小耗时也需要16ms,全部汇总接口最优状态耗时需要16ms*3=48ms 解决方案: 使用并行调用接口,通过多线程同时获取结果集,最后进行结果整合.在这种场景下,使用concurrent包的CountDownLatch完成相关操作.CountDownLatch本质上是一个计数器,把它初始化为与执行任务相同的数量,当一个任务执行完时,就将计

  • java并发包中CountDownLatch和线程池的使用详解

    1.CountDownLatch 现在做的这个华为云TaurusDB比赛中,参考的之前参加过阿里的PolarDB大赛的两个大佬的代码,发现都有用到CountDownLatch这个类,之前看代码的时候也看过,但是没有搞得很明白,自己写也写不出来,在此自己先学习一下. 字面理解:CountDownLatch:数量减少的门栓. 创建这样一个门栓 CountDownLatch countDownLatch = new CountDownLatch(count); 参数:count,门栓的计数次数. 在所

  • java并发包工具CountDownLatch源码分析

    目录 一:简述 二:什么是CountDownLatch 三:CountDownLatch的使用 四:CountDownLatch原理分析 构造函数 await()方法: doAcquireSharedInterruptibly() 1. 当前节点的前置节点是head节点 2. 当前节点的前置节点不是head节点 addWaiter() setHeadAndPropagate() shouldParkAfterFailedAcquire() parkAndCheckInterrupt() coun

  • Java并发系列之CountDownLatch源码分析

    CountDownLatch(闭锁)是一个很有用的工具类,利用它我们可以拦截一个或多个线程使其在某个条件成熟后再执行.它的内部提供了一个计数器,在构造闭锁时必须指定计数器的初始值,且计数器的初始值必须大于0.另外它还提供了一个countDown方法来操作计数器的值,每调用一次countDown方法计数器都会减1,直到计数器的值减为0时就代表条件已成熟,所有因调用await方法而阻塞的线程都会被唤醒.这就是CountDownLatch的内部机制,看起来很简单,无非就是阻塞一部分线程让其在达到某个条

  • Java并发系列之AbstractQueuedSynchronizer源码分析(概要分析)

    学习Java并发编程不得不去了解一下java.util.concurrent这个包,这个包下面有许多我们经常用到的并发工具类,例如:ReentrantLock, CountDownLatch, CyclicBarrier, Semaphore等.而这些类的底层实现都依赖于AbstractQueuedSynchronizer这个类,由此可见这个类的重要性.所以在Java并发系列文章中我首先对AbstractQueuedSynchronizer这个类进行分析,由于这个类比较重要,而且代码比较长,为了

  • Java并发系列之CyclicBarrier源码分析

    现实生活中我们经常会遇到这样的情景,在进行某个活动前需要等待人全部都齐了才开始.例如吃饭时要等全家人都上座了才动筷子,旅游时要等全部人都到齐了才出发,比赛时要等运动员都上场后才开始.在JUC包中为我们提供了一个同步工具类能够很好的模拟这类场景,它就是CyclicBarrier类.利用CyclicBarrier类可以实现一组线程相互等待,当所有线程都到达某个屏障点后再进行后续的操作.下图演示了这一过程. 在CyclicBarrier类的内部有一个计数器,每个线程在到达屏障点的时候都会调用await

  • Java并发系列之Semaphore源码分析

    Semaphore(信号量)是JUC包中比较常用到的一个类,它是AQS共享模式的一个应用,可以允许多个线程同时对共享资源进行操作,并且可以有效的控制并发数,利用它可以很好的实现流量控制.Semaphore提供了一个许可证的概念,可以把这个许可证看作公共汽车车票,只有成功获取车票的人才能够上车,并且车票是有一定数量的,不可能毫无限制的发下去,这样就会导致公交车超载.所以当车票发完的时候(公交车以满载),其他人就只能等下一趟车了.如果中途有人下车,那么他的位置将会空闲出来,因此如果这时其他人想要上车

  • Java并发系列之ConcurrentHashMap源码分析

    我们知道哈希表是一种非常高效的数据结构,设计优良的哈希函数可以使其上的增删改查操作达到O(1)级别.Java为我们提供了一个现成的哈希结构,那就是HashMap类,在前面的文章中我曾经介绍过HashMap类,知道它的所有方法都未进行同步,因此在多线程环境中是不安全的.为此,Java为我们提供了另外一个HashTable类,它对于多线程同步的处理非常简单粗暴,那就是在HashMap的基础上对其所有方法都使用synchronized关键字进行加锁.这种方法虽然简单,但导致了一个问题,那就是在同一时间

  • Java并发系列之AbstractQueuedSynchronizer源码分析(共享模式)

    通过上一篇的分析,我们知道了独占模式获取锁有三种方式,分别是不响应线程中断获取,响应线程中断获取,设置超时时间获取.在共享模式下获取锁的方式也是这三种,而且基本上都是大同小异,我们搞清楚了一种就能很快的理解其他的方式.虽然说AbstractQueuedSynchronizer源码有一千多行,但是重复的也比较多,所以读者不要刚开始的时候被吓到,只要耐着性子去看慢慢的自然能够渐渐领悟.就我个人经验来说,阅读AbstractQueuedSynchronizer源码有几个比较关键的地方需要弄明白,分别是

  • Java并发系列之ReentrantLock源码分析

    在Java5.0之前,协调对共享对象的访问可以使用的机制只有synchronized和volatile.我们知道synchronized关键字实现了内置锁,而volatile关键字保证了多线程的内存可见性.在大多数情况下,这些机制都能很好地完成工作,但却无法实现一些更高级的功能,例如,无法中断一个正在等待获取锁的线程,无法实现限定时间的获取锁机制,无法实现非阻塞结构的加锁规则等.而这些更灵活的加锁机制通常都能够提供更好的活跃性或性能.因此,在Java5.0中增加了一种新的机制:Reentrant

  • Java并发系列之AbstractQueuedSynchronizer源码分析(条件队列)

    通过前面三篇的分析,我们深入了解了AbstractQueuedSynchronizer的内部结构和一些设计理念,知道了AbstractQueuedSynchronizer内部维护了一个同步状态和两个排队区,这两个排队区分别是同步队列和条件队列.我们还是拿公共厕所做比喻,同步队列是主要的排队区,如果公共厕所没开放,所有想要进入厕所的人都得在这里排队.而条件队列主要是为条件等待设置的,我们想象一下如果一个人通过排队终于成功获取锁进入了厕所,但在方便之前发现自己没带手纸,碰到这种情况虽然很无奈,但是它

  • Java并发系列之AbstractQueuedSynchronizer源码分析(独占模式)

    在上一篇<Java并发系列[1]----AbstractQueuedSynchronizer源码分析之概要分析>中我们介绍了AbstractQueuedSynchronizer基本的一些概念,主要讲了AQS的排队区是怎样实现的,什么是独占模式和共享模式以及如何理解结点的等待状态.理解并掌握这些内容是后续阅读AQS源码的关键,所以建议读者先看完我的上一篇文章再回过头来看这篇就比较容易理解.在本篇中会介绍在独占模式下结点是怎样进入同步队列排队的,以及离开同步队列之前会进行哪些操作.AQS为在独占模

随机推荐