countdownlatch

原文： http://blog.51cto.com/liukang/2090191 Project Reactor与Spring是兄弟项目，侧重于Server端的响应式编程，主要artifact是reactor-core，这是一个基于Java 8的实现了响应式流规范（Reactive Streams specification）的响应式库。 1.Flux与Mono Reactor中发布者（Publisher）由Flux和Mono两个类定义，它们都提供了丰富的操作符。一个Flux对象代表一个包含0~N个元素的响应式序列，而一个Mono对象代表一个包含0/1个元素的结果。 即然是“数据流”的发布者，Flux和Mono都可以发现三种“数据信号”：元素值、错误信号、完成信号，错误信号和完成信号都是终止信号，完成信号用于告知下游订阅者该数据流正常结束，错误信号终止数据流的同时将错误传递给下游订阅者。 Flux.just(1, 2, 3, 4, 5, 6); Mono.just(1); Flux和Mono提供了多种创建数据流的方法，just就是一种比较直接的声明数据流的方式，其参数就是数据元素。 对于上面的Flux，还可以通过如下方式声明： Integer[] array = new Integer[]{1,2,3,4,5,6}; Flux.fromArray(array); List

概述 CountDownLatch是一个用来控制并发的很常见的工具，它允许一个或者多个线程等待其他的线程执行到某一操作，比如说需要去解析一个excel的数据，为了更快的解析则每个sheet都使用一个线程去进行解析，但是最后的汇总数据的工作则需要等待每个sheet的解析工作完成之后才能进行，这就可以使用CountDownLatch。 CountDownLatch是java.util.concurrent包中一个类，CountDownLatch只要提供的机制是多个（具体数量等于初始化CountDownLatch时count的值）线程都达到了预期状态或者完成了预期工作时触发事件，其他线程可以等待这个事件来触发自己后续的工作。等待的线程可以是多个，即CountDownLatch可以唤醒多个等待的线程。到达自己预期状态的线程会调用CountDownLatch的countDown方法，而等待的线程会调用CountDownLatch的await方法。 这里写图片描述 结合以下几个例子，可以快速掌握这个这个类的基本使用方法： 例一： public static void main(String[] args) throws InterruptedException { } public class MyRunnable implements Runnable { } 运行结果：

CountDownLatch 实例代码： package com.mmall.concurrency.example.aqs; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @Slf4j public class CountDownLatchExample1 { private final static int threadCount = 200; public static void main(String[] args) throws Exception { ExecutorService exec = Executors.newCachedThreadPool(); final CountDownLatch countDownLatch = new CountDownLatch(threadCount); for (int i = 0; i < threadCount; i++) { final int threadNum = i; exec.execute(() -> { try { test

Condition ConditionWait public class ConditionDemoWait implements Runnable{ 　　private Lock lock;　　private Condition condition; 　　public ConditionDemoWait(Lock lock, 　　Condition condition){ 　　　　this.lock=lock; 　　　　this.condition=condition; 　　} 　　@Override 　　public void run() { 　　　　System.out.println("begin -ConditionDemoWait"); 　　　　ry { 　　　　　　lock.lock(); 　　　　　　condition.await(); 　　　　　　System.out.println("end -ConditionDemoWait"); 　　　　} catch (InterruptedException e) { 　　　　　　e.printStackTrace(); 　　　　}finally { 　　　　　　lock.unlock(); 　　　　}　　} } ConditionSignal public class ConditionDemoSignal

https://blog.csdn.net/shihuacai/article/details/8856370 CountDownLatch 类介绍 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次――计数无法被重置。 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行 CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。 使用场景 在一些应用场合中，需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。 这个时候就可以使用CountDownLatch。CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。 方法说明 countDown public void countDown()

demo1 单生产者多消费者创建。 maven 依赖 <dependency> <groupId>com.lmax</groupId> <artifactId>disruptor</artifactId> <version>3.4.2</version> </dependency> 1 对象 - Message @Data @AllArgsConstructor @NoArgsConstructor @Builder public class Message2 { private String id; private String name; private double price; } 2 在主函数中创建 disruptor Disruptor disruptor = new Disruptor<>( new EventFactory() { @Override public Message2 newInstance() { return new Message2(); } }, 1 << 10, Executors.defaultThreadFactory(), ProducerType.SINGLE, new BusySpinWaitStrategy() ); 3 disruptor 绑定消费者 // disruptor 绑定消费者 disruptor

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/larva_s/article/details/90403578 文章目录 1. 场景描述 2. 原因猜测 3. 测试 3.1 默认并行流线程数 3.2 提高并行流线程数 3.3 测试结果：6w个任务 4. 总结 4.1 I/O密集型 4.1 CPU密集型 5. 参考资料 1. 场景描述 2. 原因猜测 3. 测试 @Service public class ConsumMsg { @Autowired StreamOpt streamOpt ; /** * 初始化任务队列 * @param count * @return */ public List < Integer > initMsg ( int count ) { List < Integer > list = Lists . newArrayList ( ) ; for ( int i = 0 ; i < count ; i ++ ) { list . add ( i ) ; } return list ; } /** * 并行流处理 * @param count */ public void parallel ( int count ) { List < Integer > list = initMsg ( count )

AbstractQueuedSynchronizer（抽象的队列式的同步器），AQS定义了一套多线程访问共享资源的同步器 框架 ，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch...。 它维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。 state的访问方式有三种: getState() setState() compareAndSetState() 　　AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。 自定义同步器实现时主要实现以下几种方法： isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。 tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。 tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。 tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

参考: http://www.importnew.com/21889.html CountDownLatch 　　 countDown() 方法执行完只是计数器减一, 并不会阻塞当前运行线程的的后续代码执行. 1 package org.wzh.demo.demo1; 2 3 import java.util.Random; 4 import java.util.concurrent.CountDownLatch; 5 6 public class D4CountDownLatch { 7 8 class Task extends Thread { 9 10 private CountDownLatch latch; 11 12 public Task(CountDownLatch latch) { 13 super (); 14 this .latch = latch; 15 } 16 17 @Override 18 public void run() { 19 // TODO Auto-generated method stub 20 try { 21 int time = ( new Random().nextInt(8000) + 10000) / 1000 ; 22 System.out.println(Thread.currentThread().getName() +

CountDownLatch允许一个或者多个线程一直等待，直到一组其它操作执行完成。在使用CountDownLatch时，需要指定一个整数值，此值是线程将要等待的操作数。当某个线程为了要执行这些操作而等待时，需要调用await方法。await方法让线程进入休眠状态直到所有等待的操作完成为止。当等待的某个操作执行完成，它使用countDown方法来减少CountDownLatch类的内部计数器。当内部计数器递减为0时，CountDownLatch会唤醒所有调用await方法而休眠的线程们。 下面代码演示了CountDownLatch简单使用。演示的场景是5位运动员参加跑步比赛，发令枪打响后，5个计时器开始分别计时，直到所有运动员都到达终点。 public class CountDownLatchDemo { public static void main(String[] args) { Timer timer = new Timer(5); new Thread(timer).start(); for (int athleteNo = 0; athleteNo < 5; athleteNo++) { new Thread(new Athlete(timer, "athlete" + athleteNo)).start(); } } } class Timer implements