Count_Down

背景 这两JUC类适合放一起比较，随便写写，简单小结。 CountDownLatch 要点： 底层采用AQS队列，源码很简单300行。 使用： 初始化对象并填入（计数器）值，例如：new CountDownLatch(3)。多线程执行完毕时，触发countdown方法将计数器值减1，当值为0时，主线程中被Latch拴住的代码开始执行。 用法一： public class CountDownLatch_v1 { //计数器设为3 static CountDownLatch latch = new CountDownLatch ( 3 ) ; public static void main ( String [ ] args ) throws InterruptedException { Thread t1 = new Thread ( ( ) - > { latch . countDown ( ) ; System . out . println ( "T1 is OK !" ) ; } ) ; Thread t2 = new Thread ( ( ) - > { System . out . println ( "T2 is OK !" ) ; latch . countDown ( ) ; } ) ; Thread t3 = new Thread ( ( ) - > {

你有一个思想，我有一个思想，我们交换后，一个人就有两个思想 If you can NOT explain it simply, you do NOT understand it well enough 现陆续将Demo代码和技术文章整理在一起 Github实践精选 ，方便大家阅读查看，本文同样收录在此，觉得不错，还请Star 前言 并发编程的三大核心是 分工 ， 同步 和 互斥 。在日常开发中，经常会碰到需要在主线程中开启多个子线程去并行的执行任务，并且主线程需要等待所有子线程执行完毕再进行汇总的场景，这就涉及到分工与同步的内容了 在讲 有序性可见性，Happens-before来搞定 时，提到过 join() 规则，使用 join() 就可以简单的实现上述场景： @Slf4j public class JoinExample { public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } finally { log.info("Thread-1 执行完毕"); } }

CountDownLatch见名思义，即倒计时器，是多线程并发控制中非常有用的工具类，它可以控制线程等待，直到倒计时器归0再继续执行。 给你出个题，控制5个线程执行完后主线徎再往下执行，并统计5个线程的所耗时间。当然我们可以通过join的形式完成这道题，但如果我说统计100个1000个线程呢？难道要写1000个join等待吗？这显然是不现实的。 废话少说，我们来做一个例子看看上面的题怎么实现，并理解倒计时器。 首先通过new CountDownLatch(5)约定了倒计时器的数量，在这里也是线程的数量，每个线程执行完后再对倒计时器-1。countDown()方法即是对倒计时器-1，这个方法需要放在finally中，一定要保证在每个线程中得到释放，不然子线程如果因为某种原因报错倒计时器永远不会清0，则会导报主线程会一直等待。 await()方法即是主线程阻塞等待倒计器归0后再继续往下执行，当然await可以带时间进去，等待多久时间后不管倒计时器有没有归0主线程继续往下执行。 如上面的例子所示，我们输出了倒计时器最后的数字0，表示倒计时器归0了，也输出了从开始到结束所花费的时间。从这个例子可以完全理解倒计时器的含义，这个工具类在实际开发经常有用到，也很好用。 推荐去我的博客阅读更多： 1. Java JVM、集合、多线程、新特性系列教程 2. Spring MVC、Spring

前言 原文地址： github/Nealyang 没有想到之前写的一篇 一张页面引起的前端架构思考 还收到不少同学关注。的确，正如之前在群里所说，一个系统能有一个非常好的架构设计。但是仅仅对于前端项目页面，其实很难把 架构 一词搬出来聊个天花乱坠。 但是！好的代码结构的组织的确能够避免一些不必要的采坑。当然，这其中也不乏对前端工程师的工程师素养约束。 一言以蔽之，对于前端项目的架构（代码组织）而言， 好 ，好不到哪里去。但是 坏 ，却可以令人头皮发麻。 当然。。。我还是在尽可能的希望好~这也是这篇文章的目的所在。 此处权且抛个砖，如果你有更好的见解和想法，欢迎随时交流~ 拍卖详情页 详情页 图上的点我会在下文中挨个介绍 架构设计图 特点 稳定性要求极高 （这一点区分手淘和天猫，毕竟 拍卖 ...你品） 需要详细的日志打点 模块之间的通信非常多（拍品状态、倒计时、出价等） 对于手淘和天猫的商品，一般都是多个人对多个物品。即使出了问题，也不影响购买，大不了问题修复再购买（最坏的情况）。 但是对于拍卖的拍品。对多对一、价高者得的属性。并且具有一定的法律效应。所以稳定性的要求极其之高。同时拍卖又具有非常高时效性要求，所以 apush、轮询啥的都要求实时更新拍品的状态。 综合以上因素的考虑。最终我们没有选择大黄蜂搭建页面的形式构建起详情页。就先走了源码链路的开发。 至于后续是否会推进落地

使用CountDownLatch，这其实是最优雅的写法了，每个线程完成后都去将计数器减一，最后完成时再来唤醒 @Test public void testThreadSync3() { final Vector<Integer> list = new Vector<Integer>(); Thread[] threads = new Thread[TEST_THREAD_COUNT]; final CountDownLatch latch = new CountDownLatch(TEST_THREAD_COUNT); for (int i = 0; i < TEST_THREAD_COUNT; i++) { final int num = i; threads[i] = new Thread(new Runnable() { public void run() { try { Thread.sleep(random.nextInt(100)); } catch (InterruptedException e) { e.printStackTrace(); } list.add(num); System.out.print(num + " add.\t"); latch.countDown(); } }); threads[i].start(); } try { latch

1.背景： countDownLatch是在java1.5被引入，跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。 存在于java.util.cucurrent包下。 2.概念 countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。 3.源码 countDownLatch类中只提供了一个构造器： //参数count为计数值 public CountDownLatch( int count) { }; 类中有三个方法是最重要的： // 调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行 public void await() throws InterruptedException { }; // 和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行 public boolean await( long timeout, TimeUnit unit) throws InterruptedException { }; // 将count值减1

一、CountDownLatch 1.1 定义 它是一个同步辅助类，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。一个倒数计算的概念。 初始化给定一定的整数参数值，然后通过countDown()来实现倒数功能，在这个整数倒数到 0 之前，调用了 await() 方法的程序都必须要等待，当到达0后， 释放所有等待线程。 1.2 源码分析 对于 CountDownLatch，我们仅仅需要关心两个方法，一个是 countDown () 方法，另一个是 await () 方法。 1.2.1 countDown() CountDownLatch有一个同步内部类 Sync ： 它使用AQS状态表示计数，实现同步控制。 /** * Synchronization control For CountDownLatch. * Uses AQS state to represent count. */ private static final class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = 4982264981922014374L; Sync(int count) { setState(count); } int getCount() { return

前言： 在多线程中线程的执行顺序是依靠哪个线程先获得到CUP的执行权谁就先执行，虽然说可以通过线程的优先权进行设置，但是他只是获取CUP执行权的概率高点，但是也不一定必须先执行。在这种情况下如何保证线程按照一定的顺序进行执行，今天就来一个大总结，分别介绍一下几种方式。 一、通过Object的wait和notify 二、通过Condition的awiat和signal 三、通过一个阻塞队列 四、通过两个阻塞队列 五、通过SynchronousQueue 六、通过线程池的Callback回调 七、通过同步辅助类CountDownLatch 八、通过同步辅助类CyclicBarrier 一、通过Object的wait和notify 写一个测试了Test，加上main方法，在写一个内部类Man进行测试。main方法如下，他进行创建两个线程，传进去Runnable对象。 public static boolean flag = false; public static int num = 0; public static void main(String[] args) { Man man = new Man(); new Thread(() -> { man.getRunnable1(); }).start(); new Thread(() -> { man.getRunnable2();

CountDownLatch： 　　 可以让一个线程等待其他线程完成了各自的工作之后再执行。比如说一个切菜，一个人切肉，都准备完毕之后才能炒肉。 构造方法 ： public CountDownLatch(int count) count 等待的线程数量 关键 API ： countDown() 分线程执行完减少计数 await() 主线程等待调用 使用 ： package com.nijunyang.concurrent; import java.util.concurrent.CountDownLatch; /** * Description: * Created by nijunyang on 2020/5/16 13:53 */ public class CountDownLatchTest{ private CountDownLatch countDownLatch; public CountDownLatchTest(CountDownLatch countDownLatch) { this .countDownLatch = countDownLatch; } public static void main(String[] args) throws InterruptedException { CountDownLatch countDownLatch = new

前言 CountDownLatch和CyclicBarrier两个同为java并发编程的重要工具类，它们在诸多多线程并发或并行场景中得到了广泛的应用。但两者就其内部实现和使用场景而言是各有所侧重的。 内部实现差异 前者更多依赖经典的AQS机制和CAS机制来控制器内部状态的更迭和计数器本身的变化，而后者更多依靠可重入Lock等机制来控制其内部并发安全性和一致性。 public class { //Synchronization control For CountDownLatch. //Uses AQS state to represent count. private static final class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = 4982264981922014374L; Sync(int count) { setState(count); } int getCount() { return getState(); } protected int tryAcquireShared(int acquires) { return (getState() == 0) ? 1 : -1; } protected boolean