countdownlatch

CountDownLatch和CyclicBarrier都是控制并发而生，都在java.util.concurrent包下。 CountDownLatch 简单称为计数器，适合1个或者多个线程等待其他线程执行完毕后自己开始执行。其中最主要的方法是await和countDown，调用await()的线程如果CountDownLatch内部count变量不为0，则一直阻塞，直到为0，并且可以有多个线程调用await(),也就是多个线程同时等待。 下面的例子先创建两个线程，一直等待，然后启动10个线程对CountDownLatch进行减少。10次countDown()后，前两个线程才可以运行。 public class Main2 { static CountDownLatch countDownLatch = new CountDownLatch ( 10 ) ; public static void main ( String [ ] args ) throws InterruptedException { for ( int i = 0 ; i < 2 ; i ++ ) { new Thread ( ( ) - > { try { System . out . println ( Thread . currentThread ( ) + " start" ) ;

CountDownLatch作用、应用场景和实战 CountDownLatch 作用：是一组线程等待其他的线程完成工作以后再执行，加强版join() await 用来等待，countDown 负责计数器的减一 UseCountDownLatch package com.xiangxue.ch2.tools; import java.util.concurrent.CountDownLatch; import com.xiangxue.tools.SleepTools; /** * *类说明：演示CountDownLatch，有5个初始化的线程，6个扣除点， *扣除完毕以后，主线程和业务线程才能继续自己的工作 */ public class UseCountDownLatch { static CountDownLatch latch = new CountDownLatch(6); //6个扣除点 //初始化线程(只有一步，有4个) private static class InitThread implements Runnable{ @Override public void run() { System.out.println("Thread_"+Thread.currentThread().getId() +" ready init work......"); latch

CountDownLatch CountDownLatch类似一个计数的工具，是等待其他线程完成工作以后，相当于加强版的join(),和join()又有所不同，join()是等待一个线程完成，而CountDownLatch只要你在进行countDown操作到0的时候，就会完成初始化，并不代表其他线程关闭了，而join()是等待其他线程执行完了才行，这一点有所不同 import java . util . concurrent . CountDownLatch ; public class countdowla { static CountDownLatch count = new CountDownLatch ( 5 ) ; public static void main ( String [ ] args ) { Thread target = new Thread ( new myThread1 ( ) ) ; target . start ( ) ; for ( int i = 0 ; i < 5 ; i ++ ) { new Thread ( new myThread ( ) ) . start ( ) ; } } public static class myThread implements Runnable { @Override public void run ( )

今天给大家分享一下一个经典的案例,供给他人学习以及自己今天的回首展望,首先让我们先看一下需求: 1.并行生成任务,id是唯一,不能重复 2.并行消费,id按照升序打印出来 3.精确任务到200个,并计算出消费时间 首先根据需求分析,我们首先来创建一个实体类,该实体类只有一个id属性,并提供get set方法和构造函数 public class Task { private Integer id; public Task(Integer id) { this.id = id; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } } 然后创建生产者和消费者的对应的接口 //生产者 public interface Prodeucer { void produce() throws InterruptedException; } //消费者 public interface Consumer { void consumer()throws InterruptedException; } 根据最近所研究的模板模式,正好这个案例就将他实用上,创建生产者和消费者的接口实现类 //生产者接口实现类 public abstract class

CountDownLatch CountDownLatch 基于AQS实现的同步器，允许一个或者多个线程通过 await() 方法进入阻塞等待，直到一个或者多个线程执行 countDown() 完成。 CountDownLatch 在创建时需要传入一个 count 值，一旦某个或者多个线程调用了 await() 方法，那么需要等待 count 值减为0，才能继续执行。 countDown() 方法每执行一次，count(state)值减1，直到减为0。一个线程可以多次调用 countDown() 方法，每次调用都会造成count减1 CountDownLatch 在RocketMQ底层通信被大量使用，实现远程调用异步转同步。 Netty Client 发送消息之前创建一个 ResponseFuture ， ReponseFuture 中有一个 CountDownLatch 属性，发送消息之后调用 await() ，等待response，当接收到响应之后，调用对应 ResponseFuture 中 CountDownLatch#countDown ，唤醒阻塞线程。 内部类AQS实现 private static final class Sync extends AbstractQueuedSynchronizer { private static final long

ArrayList线程安全问题 众所周知， ArrayList 不是线程安全的，在并发场景使用 ArrayList 可能会导致add内容为null,迭代时并发修改list内容抛 ConcurrentModificationException 异常等问题。java类库里面提供了以下三个轮子可以实现线程安全的List，它们是 Vector Collections.synchronizedList CopyOnWriteArrayList 本文简要的分析了下它们线程安全的实现机制并对它们的读，写，迭代性能进行了对比。 Vector 从JDK1.0开始， Vector 便存在JDK中， Vector 是一个线程安全的列表，底层采用数组实现。其线程安全的实现方式非常粗暴： Vector 大部分方法和 ArrayList 都是相同的，只是加上了 synchronized 关键字，这种方式严重影响效率，因此，不再推荐使用 Vector 了。JAVA官方文档中这样描述： If a thread-safe implementation is not needed, it is recommended to use ArrayList in place of Vector. 如果不需要线程安全性，推荐使用ArrayList替代Vector 关键源码如下： public synchronized

CountDownLatch:门阀 构造方法: // count为门阀数，必须大于0，否则抛出异常 CountDownLatch countDownLatch = new CountDownLatch ( int count ) ; 举个例子：在运动会上短跑比赛的时候，有8个运动员和一个裁判,把裁判当做主线程，只有等8个运动员全部完成比赛，有成绩之后，才能做出统计，完成后面的操作（调用await方法）,每个运动员到达终点，都会调用(countdown方法)，使门阀数减一，当8个运动员全部到终点的时候，门阀数为0，此时裁判员才能继续往下执行 主要方法： countDownLatch.awati()方法: 调用这个方法的线程会等到构造方法传入的 count 减到 0 的时候，才能继续往下执行； countDownLatch.countdown()方法: 每次调用，构造方法传入的count数就会减1 使用场景: 让所有线程几乎在同一时间内一起工作： 思路:设置一个门阀，其他线程调用await方法等待，让主函数去打开阀门(调用countdown方法)，count为0的时候，所有线程就会一起工作 代码： 门阀类：提供需要调用的等待方法，写到一个类里也可以 class JymCountDownLatch { // 门阀类 private CountDownLatch

什么是线程？ 线程是操作系统能够进行运算调度的最小单位，被包含在进程中。线程也叫作轻量级进程，在一个进程里可以创建多个线程，每个线程都有独立的计数器，堆，栈和局部变量，并且能够访问共享的内存变量 线程和进程的区别？ 线程是一个轻量级进程，一个进程可以有多个线程，各条线程能够执行不同的任务，不同的进程使用不同的内存空间，而所有的线程共享相同的内存空间 如何在java中实现线程？ 在语言层面有两种方式。Thread类的一个实例就是一个线程，但是需要调用Runnable接口来执行，由于线程类本身就是调用的Runnable接口，所以可以继承Thread类或者直接调用Runnable接口来重写run（）方法实现线程 Runnable还是Thread？ 由于java是单继承的，如果一个类继承了另一个类，再想实现多线程，这时候再继承Thread是不行的，因为这样就是多继承了，可是java不允许，所以如果要继承其他类，那么实现Runnable接口吧（java不能多继承，但是能实现多个接口啊） 并且Runnable适合于资源的共享 因为线程是独立的，所以局部变量不共享，而如果是实现Runnable接口，那么在开一个新线程new Thread（myRunnable,"线程的名字"）时，所有的线程都共享接口内的资源（实现了Runnable接口的类的资源） 所以多线程主要以实现Runnable接口为主

CountDownLatch 用来控制一个或者多个线程等待多个线程。 内部使用了一个计数器，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。 import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicInteger; public class CountDownLatchExample { public static long a = 0; public static void main(String[] args) throws InterruptedException { final int threadSize = 1000; final CountDownLatch countDownLatch = new CountDownLatch(threadSize); AtomicInteger atomicInteger=new AtomicInteger();//原子性类 ExecutorService

先来说一下对异步和同步的理解： 同步调用：调用方在调用过程中，持续等待返回结果。 异步调用：调用方在调用过程中，不直接等待返回结果，而是执行其他任务，结果返回形式通常为回调函数。 其实，两者的区别还是很明显的，这里也不再细说，我们主要来说一下Java如何将异步调用转为同步。换句话说，就是需要在异步调用过程中，持续阻塞至获得调用结果。 不卖关子，先列出五种方法，然后一一举例说明： 使用wait和notify方法,synchronized 使用条件锁ReentrantLock Future 使用CountDownLatch 使用CyclicBarrier 0.构造一个异步调用 首先，写demo需要先写基础设施，这里的话主要是需要构造一个异步调用模型。异步调用类: public class AsyncCall { private Random random = new Random(System.currentTimeMillis()); private ExecutorService tp = Executors.newSingleThreadExecutor(); //demo1,2,4,5调用方法 public void call(BaseDemo demo){ new Thread(()->{ long res = random.nextInt(10); try { Thread