Java高并发编程中CountDownLatch的详细介绍-刘宇

最新推荐文章于 2024-08-03 17:46:09 发布
最新推荐文章于 2024-08-03 17:46:09 发布
阅读量530 收藏 2
点赞数
分类专栏： Java 文章标签： java 高并发 多线程 CountDownLatch Thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuyu973971883/article/details/107733627
版权

Java高并发编程中CountDownLatch的详细介绍-刘宇

作者：刘宇
CSDN博客地址：https://blog.csdn.net/liuyu973971883
有部分资料参考，如有侵权，请联系删除。如有不正确的地方，烦请指正，谢谢。

一、CountdownLatch简介

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。CountDownLatch能够使一个或多个线程在等待其他一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，则表示所有的线程都已经完成任务，然后在CountDownLatch上等待的线程就会继续执行下面的代码。

二、基本用法

1、构造方法

  • 参数count为任务数量
public CountDownLatch(int count)

2、await()

  • 调用await()方法的线程会被挂起，它会等待直到count值为0或者调用await()方法的线程被打断才继续执行
public void await() throws InterruptedException

3、await(long timeout, TimeUnit unit)

  • 调用await()方法的线程会被挂起，等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException

4、countDown()

  • count值会减1
public void countDown()

三、使用场景

1、场景1

当我们从数据库查询到数据后，由于数据量庞大且要进行处理，那么我们就需要使用线程对数据进行处理，在处理完成后，我们要将处理完的数据进行保存操作。

package com.test.part3.countdown;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {
    private static Random random = new Random(System.currentTimeMillis());
    //定义一个线程池，里面有两个线程
    private static ExecutorService executorService = Executors.newFixedThreadPool(2);
    //定义CountDownLatch，设置任务数为10
    private static CountDownLatch countDownLatch = new CountDownLatch(10);
    public static void main(String[] args) throws InterruptedException {
        //模拟从数据库查询数据
        int[] data = query();

        for (int i=0;i<data.length;i++){
            executorService.execute(new SimpleRunnable(data,i));
        }

        countDownLatch.await();
        executorService.shutdown();
        //模拟保存操作
        System.out.println("进行保存等操作...");
    }

    public static int[] query(){
        return new int[]{1,2,3,4,5,6,7,8,9,10};
    }

    static class SimpleRunnable implements Runnable {
        private final int[] data;
        private final int index;

        public SimpleRunnable(int[] data, int index) {
            this.data = data;
            this.index = index;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(random.nextInt(2000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int value = data[index];
            //模拟处理数据，单数*10，双数*2
            if (value % 2 == 0){
                data[index] = value * 2;
            }else {
                data[index] = value * 10;
            }
            System.out.println(Thread.currentThread().getName()+"->完成角标："+index+"的数据处理");
            //任务数减1
            countDownLatch.countDown();
        }
    }
}

输出结果：

pool-1-thread-1->完成角标：0的数据处理
pool-1-thread-2->完成角标：1的数据处理
pool-1-thread-1->完成角标：2的数据处理
pool-1-thread-2->完成角标：3的数据处理
pool-1-thread-2->完成角标：5的数据处理
pool-1-thread-1->完成角标：4的数据处理
pool-1-thread-2->完成角标：6的数据处理
pool-1-thread-2->完成角标：8的数据处理
pool-1-thread-2->完成角标：9的数据处理
pool-1-thread-1->完成角标：7的数据处理
进行保存等操作...

Process finished with exit code 0

2、场景2

假设我们需要将一边的数据库迁移到一个数据壶中，并且需要保证迁移的每张表数据量正确和每张表数据结构正确。那么就需要一些服务器做迁移工作，一些服务器做校验工作。

  • 思路：
  1. 迁移服务器在获取一次数据肯定是一次迁移保存许多表的，且每张表有大量数据。保存数据后，将每张数据表的名称、抓取的数据量、抓取的数据表结构生成一个Event事件发送给校验服务器。
  2. 校验服务器拿到Event事件，对每张表的校验任务(校验数据量、校验数据结构等)分为许多子任务去校验，随后将校验信息保存的数据量和抓取的数据量是否一致、抓取的数据结构和保存的数据结构是否一致等保存到数据库中。那么问题来了，我们不能每校验一个子任务就去更新一次数据库，那无疑是一种非常消耗资源的事情，我们此时就可以利用CountDownLatch来完成，当一张表中的子任务全部校验完成后再保存校验信息。
  3. 一个Event事件里面是包含很多张表的，那么如何在全部校验完这个Event事件里的所有表后给迁移服务器一个响应呢，也可以使用CountDownLatch来完成。
  • 代码：

Table.java

package com.test.part3.countdown;

/**
* 记录所处理table的名称，获取时拿到的原数据条数，数据库结构。
* target属性主要用于判断存入数据壶中的数据条数，数据结构是否与原先的一致。
*/
public class Table {
   public String tableName;//抓取的表名称
   public long sourceRecordCount;//抓取的数据量
   public long targetRecoudCount = 0;//保存数据量是多少，由校验服务器获取
   public String sourceColumnSchema;//抓取的数据表结构
   public String targetColumnSchema = "";//保存数据表结构，由校验服务器获取

   public Table(String tableName, long sourceRecordCount, String sourceColumnSchema) {
       this.tableName = tableName;
       this.sourceRecordCount = sourceRecordCount;
       this.sourceColumnSchema = sourceColumnSchema;
   }

   @Override
   public String toString() {
       return "Table{" +
               "tableName='" + tableName + '\'' +
               ", sourceRecordCount=" + sourceRecordCount +
               ", targetRecoudCount=" + targetRecoudCount +
               ", sourceColumnSchema='" + sourceColumnSchema + '\'' +
               ", targetColumnSchema='" + targetColumnSchema + '\'' +
               '}';
   }
}

·Event.java

package com.test.part3.countdown;

/**
* 事件类，在获取完数据存入数据壶中后生成事件，将所处理的所有table等信息传递给另一个组件进行数据校验
*/
public class Event {
   private int id;

   public Event(int id) {
       this.id = id;
   }

   public int getId() {
       return id;
   }
}

RecordCountCheck.java

package com.test.part3.countdown;

import java.util.Random;

/**
 * 数据量校验
 * 将一次Event任务的一张表中的多个检查分为多个小的检查
 */
public class RecordCountCheck implements Runnable {
    private Random random = new Random(System.currentTimeMillis());
    private Table table;
    private TaskBatch tasKBatch;

    public RecordCountCheck(Table table, TaskBatch tasKBatch) {
        this.table = table;
        this.tasKBatch = tasKBatch;
    }

    @Override
    public void run() {
        //模拟获取数据壶中的数据量，这边就当和原数据量一致了。
        try {
            Thread.sleep(random.nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        table.targetRecoudCount = table.sourceRecordCount;
        //通知该张表的一个子任务校验完成
        tasKBatch.done(table);
    }
}

ColumnSchemaCheck.java

package com.test.part3.countdown;

import java.util.Random;

/**
 * 数据库结构校验
 * 将一次Event任务的一张表中的多个检查分为多个小的检查
 */
public class ColumnSchemaCheck implements Runnable {
    private Random random = new Random(System.currentTimeMillis());
    private Table table;
    private TaskBatch tasKBatch;

    public ColumnSchemaCheck(Table table, TaskBatch tasKBatch) {
        this.table = table;
        this.tasKBatch = tasKBatch;
    }

    @Override
    public void run() {
        //模拟获取数据壶中的数据结构，这边就当和原数据结构一致了。
        try {
            Thread.sleep(random.nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        table.targetColumnSchema = table.sourceColumnSchema;
        //通知该张表的一个子任务校验完成
        tasKBatch.done(table);
    }
}

Watcher.java

package com.test.part3.countdown;

/**
 * 定义观察任务是否完成接口
 */
interface Watcher {
    void done(Table table);
}

TaskBatch.java

package com.test.part3.countdown;

import java.util.concurrent.CountDownLatch;

/**
 * 每张表中子任务完成通知类，一张表中的子任务全部完成后进行保存该校验数据操作
 */
public class TaskBatch implements Watcher {
    private CountDownLatch countDownLatch;//用于判断该张表中所有的校验子任务是否都完成
    private TaskGroup taskGroup;//Event中表完成通知类
    private volatile boolean isUpdate = false;

    public TaskBatch(TaskGroup taskGroup, int size) {
        this.countDownLatch = new CountDownLatch(size);
        this.taskGroup = taskGroup;
    }

    @Override
    public void done(Table table) {
        //每完成一个子任务就减1
        countDownLatch.countDown();
        synchronized (this) {
            //判断是否为0，且没有保存到数据库中
            if (countDownLatch.getCount() == 0 && !isUpdate) {
                isUpdate = true;
                System.out.println("The table " + table.tableName + " finished work." + table.toString());
                //通知该张表完成了所有子任务查询
                taskGroup.done(table);
            }
        }
    }
}

TaskGroup.java

package com.test.part3.countdown;

import java.util.concurrent.CountDownLatch;

/**
 * 每张表完成通知，全部表完成后对Event事件做出响应
 */
public class TaskGroup implements Watcher {
    private CountDownLatch countDownLatch;//用于判断该Event事件中所有的表是否都完成
    private Event event;
    private volatile boolean isFinish = false;

    public TaskGroup(Event event,int size) {
        this.countDownLatch = new CountDownLatch(size);
        this.event = event;
    }

    @Override
    public void done(Table table) {
        //完成一张表就减1
        countDownLatch.countDown();
        synchronized (this) {
            //当count为0时且没有做出响应时对该Event事件做出响应
            if (countDownLatch.getCount() == 0 && !isFinish) {
                isFinish = true;
                System.out.println("Event "+event.getId()+" finished work");
            }
        }
    }
}

CountDownLatchExample2.java

package com.test.part3.countdown;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample2 {
    public static void main(String[] args) {
        //模拟两台数据迁移服务器分别获取完数据存入数据壶后传递过来的Event事件，通知校验服务器进行校验工作
        Event[] events = new Event[] {new Event(1),new Event(2)};
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (Event event : events){
            //模拟获取到数据迁移服务器传递过来的event的数据
            List<Table> tables = capture(event);
            TaskGroup taskGroup = new TaskGroup(event,tables.size());
            for (Table table : tables){
                //一个表中需要检查两项，所以这边设置任务数2
                TaskBatch tasKBatch = new TaskBatch(taskGroup,2);
                //数据量校验子任务
                RecordCountCheck recordCountCheck = new RecordCountCheck(table,tasKBatch);
                //数据结构校验子任务
                ColumnSchemaCheck columnSchemaCheck = new ColumnSchemaCheck(table,tasKBatch);
                //提交任务
                executorService.submit(recordCountCheck);
                executorService.submit(columnSchemaCheck);
            }
        }
    }

    //模拟生成该Event事件对应的数据
    public static List<Table> capture(Event event){
        List<Table> list = new ArrayList<>();
        for (int i=0;i<10;i++){
            //封装数据迁移服务器迁移的数据表、该表数据量、表结构等信息
            list.add(new Table("table-"+i+"::event-"+event.getId(),i*1000,"<table name='a'><column name='coll' type='varchar2' /></table>"));
        }
        return list;
    }
}

输出结果：

The table table-2::event-1 finished work.Table{tableName='table-2::event-1', sourceRecordCount=2000, targetRecoudCount=2000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-1::event-1 finished work.Table{tableName='table-1::event-1', sourceRecordCount=1000, targetRecoudCount=1000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-0::event-1 finished work.Table{tableName='table-0::event-1', sourceRecordCount=0, targetRecoudCount=0, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-3::event-1 finished work.Table{tableName='table-3::event-1', sourceRecordCount=3000, targetRecoudCount=3000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-4::event-1 finished work.Table{tableName='table-4::event-1', sourceRecordCount=4000, targetRecoudCount=4000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-5::event-1 finished work.Table{tableName='table-5::event-1', sourceRecordCount=5000, targetRecoudCount=5000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-6::event-1 finished work.Table{tableName='table-6::event-1', sourceRecordCount=6000, targetRecoudCount=6000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-7::event-1 finished work.Table{tableName='table-7::event-1', sourceRecordCount=7000, targetRecoudCount=7000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-8::event-1 finished work.Table{tableName='table-8::event-1', sourceRecordCount=8000, targetRecoudCount=8000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-9::event-1 finished work.Table{tableName='table-9::event-1', sourceRecordCount=9000, targetRecoudCount=9000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
Event 1 finished work
The table table-0::event-2 finished work.Table{tableName='table-0::event-2', sourceRecordCount=0, targetRecoudCount=0, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-1::event-2 finished work.Table{tableName='table-1::event-2', sourceRecordCount=1000, targetRecoudCount=1000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-2::event-2 finished work.Table{tableName='table-2::event-2', sourceRecordCount=2000, targetRecoudCount=2000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-3::event-2 finished work.Table{tableName='table-3::event-2', sourceRecordCount=3000, targetRecoudCount=3000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-4::event-2 finished work.Table{tableName='table-4::event-2', sourceRecordCount=4000, targetRecoudCount=4000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-5::event-2 finished work.Table{tableName='table-5::event-2', sourceRecordCount=5000, targetRecoudCount=5000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-6::event-2 finished work.Table{tableName='table-6::event-2', sourceRecordCount=6000, targetRecoudCount=6000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-7::event-2 finished work.Table{tableName='table-7::event-2', sourceRecordCount=7000, targetRecoudCount=7000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-8::event-2 finished work.Table{tableName='table-8::event-2', sourceRecordCount=8000, targetRecoudCount=8000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
The table table-9::event-2 finished work.Table{tableName='table-9::event-2', sourceRecordCount=9000, targetRecoudCount=9000, sourceColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>', targetColumnSchema='<table name='a'><column name='coll' type='varchar2' /></table>'}
Event 2 finished work
Brycen Liu
关注
专栏目录
java并发编程专题（八）----（JUC）实例讲解CountDownLatch
08-18
本篇文章主要介绍了Java中的CountDownLatch类，作为Java并发编程专题（八）的一部分，通过实例讲解帮助读者理解和学习。下面是文章中的知识点总结： 一、CountDownLatch简介 CountDownLatch是一个同步辅助类，允许...
查询mysql 30g大文件_30G 上亿数据的超大文件，如何快速导入生产环境？
weixin_39695241的博客
01-20 421
Hello，大家好，我是楼下小黑哥~如果给你一个包含一亿行数据的超大文件，让你在一周之内将数据转化导入生产数据库，你会如何操作？上面的问题其实是小黑哥前段时间接到一个真实的业务需求，将一个老系统历史数据通过线下文件的方式迁移到新的生产系统。由于老板们已经敲定了新系统上线时间，所以只留给小黑哥一周的时间将历史数据导入生产系统。由于时间紧，而数据量又超大，所以小黑哥设计的过程想到一下解决办法：拆分文件...
开发日记——CountDownLatch同步数据
V_S1r的博客
02-16 340
业务背景 这次的业务场景是公司的旧系统使用单线程同步接口，而需要同步的数据量已经逐渐扩大到几十万上百万，导致同步一次数据需要将近半天时间。 对此我想到使用多线程优化系统。 CountDownLatch 概念 CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程执行完后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行。 简单来说就是我准备线程池让程序自动分配每个线程执行的任务，虽然执行顺序是乱序的，但保证了任务唯一。
CountDownLatch简介
最新发布
qq_34358193的博客
08-03 409
是 Java 并发包中的一个类，它允许一个或多个线程等待其他线程完成一组操作。是一种同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
java await用法_Java线程中wait、await、sleep、yield、join用法总结
weixin_39674293的博客
02-13 487
一、wait()、notify()、notifyAll()用法obj.wait()/obj.wait(long timeout)是Object中的方法，当线程调用wait()方法，当前线程释放对象锁，进入等待队列。obj.notify()/obj.nogifyAll()是Object中的方法，唤醒在此对象上wait()的单个或者所有线程。测试代码：public class ThreadWaitNo...
Java线程中wait、await、sleep、yield、join用法总结
xtho62的博客
02-20 1306
1.Thread.yield()：一定是当前线程调用此方法，当前线程放弃获取CPU的时间片，由运行态转变为就绪态，让操作系统中再次选择线程执行。2.t.join()/t.join(long millis)：当前线程调用t2.join()方法，当前线程阻塞但是不会释放对象锁，直到t2线程执行完毕或者millis时间到，则当前的线程恢复就绪状态。obj.wait()/obj.wait(long timeout)是Object中的方法，当线程调用wait()方法，当前线程释放对象锁，进入等待队列。
Java并发编程知识点总结（十二）——Condition中await和signal通知机制
XHHP
09-10 1953
线程A处于同步队列中，竞争中获得锁线程A在执行过程中调用Condition.await()方法，线程A释放锁，进入到condition条件队列中当线程A成为条件队列头部时，并且其他线程调用signal方法时，就会进入到同步队列的尾部进行排队线程A重新尝试获得锁。
Java并发编程-3.pdf
05-28
CountDownLatch、CyclicBarrier 和 Semaphore 等多线程协作机制都是 Java 并发编程中的重要组成部分。它们可以帮助开发者编写高效、可靠的多线程程序，解决复杂的并发问题。 在实际开发中，我们可以根据具体情况...
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解 ...CountDownLatch、CyclicBarrier和Semaphore都是Java并发编程中非常重要的辅助类，它们可以帮助开发者更好地进行并发编程。
java并发编程中CountDownLatch和CyclicBarrier的使用借鉴.pdf
11-28
java并发编程中CountDownLatch和CyclicBarrier的使用借鉴 java并发编程中CountDownLatch和CyclicBarrier是两个非常重要的线程控制和调度工具，经常被用于解决多线程程序设计中的线程等待问题。本文将对...
java并发编程中CountDownLatch和CyclicBarrier的使用.pdf
10-04
在Java并发编程中，CountDownLatch和CyclicBarrier是两种非常重要的同步工具，用于协调多个线程之间的交互。它们都属于java.util.concurrent包下的类，为多线程编程提供了强大的支持。 **CountDownLatch** 是一个...
Java并发：await/wait的区别
LiZhen314的博客
04-26 8920
await/wait Sleep Yield 是否释放持有的锁 释放 不释放 不释放 调用后何时恢复 唤醒后进入就绪态 指定时间后 立刻进入就绪态 ...
java异步方法 Async/Await
m0_61696809的博客
02-27 2032
我们将异步函数声明为 async 函数，这样就可以在该函数内使用 await 关键字。在上面的代码中，我们使用了 fetch 函数发送了一个请求，并使用 await 表达式等待请求完成。然后，我们使用了 response.json() 方法将请求的结果转换为 JSON 格式，并使用 await 表达式等待转换完成。在 JavaScript 引擎内部，Async/Await 实际上是通过生成 Generator 函数并使用该函数来处理异步操作的。异步函数是通过在函数前面添加 async 关键字来声明的。
java 异步的await_深入理解async/await来处理异步
weixin_34921054的博客
03-07 4769
目前async/await 已经被标准化，我们需要尽快将学习进程提上日程。先说一下async的用法，它作为一个关键字放到函数前面，用于表示函数是一个异步函数，因为async就是异步的意思，异步函数也就意味着该函数的执行不会阻塞后面代码的执行。下面写一个async 函数：async function timeout() {return 'hello world';}语法很简单，就是在函数前面加上as...
Java并发基础 - CountDownLatch&CyclicBarrier
m0_62301431的博客
10-22 187
CountDownLatch CountDownLatch可以看作一个计数器，并且这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。先看一下常用的几个重要方法，首先看构造方法： CountDownLatch countDownLatch=new CountDownLatch(count); 复制代码 构造器中传入的count为int类型，这个计数器的初始值就是需要等待的线程数量。这个值只能被设置一次，并且CountDownLatch不提供
java多线程
qq_46075833的博客
08-11 218
线程的分类 用户线程：执行完后才可以停下，用户创建的线程默认为用户线程 守护线程：保护用户线程，Java虚拟机不会因为守护线程是否执行完毕而等待 1.线程的创建方式： 继承Thread类 实现Runnnable接口 实现Callable接口通过FutureTask包装器来创建Thread线程,实现call()方法 注： 在面向对象中尽量多用实现少用继承，因为在Java中存在单继承的局限性。 2.线程基本方法： Jion（）（等待其他线程终止）：
java 异步的await_并行调用异步/等待功能
weixin_30750685的博客
03-07 836
据我了解，在ES7 / ES2016中，在代码中放置多个await的工作方式类似于将带有.then()的承诺链接在一起，这意味着它们将一个接一个地执行而不是并行执行。 因此，例如，我们有以下代码：await someCall();await anotherCall();我是否正确理解只有在someCall()完成后才会调用anotherCall() ？ 并行调用它们的最优雅方式是什么？我想在Nod...
java asynccallback_5种必会的Java异步调用转同步的方法你会几种
weixin_39696518的博客
02-16 653
Sunny先来说一下对异步和同步的理解：同步调用：调用方在调用过程中，持续等待返回结果。异步调用：调用方在调用过程中，不直接等待返回结果，而是执行其他任务，结果返回形式通常为回调函数。其实，两者的区别还是很明显的，这里也不再细说，我们主要来说一下Java如何将异步调用转为同步。换句话说，就是需要在异步调用过程中，持续阻塞至获得调用结果。不卖关子，先列出五种方法，然后一一举例说明：使用wait和no...
java await原理_一文带你理解java中的同步工具类CountDownLatch
weixin_34334554的博客
02-16 950
这篇文章主要讲解java中一个比较常用的同步工具类CountDownLatch，不管是在工作还是面试中都比较常见。我们将通过案例来进行讲解分析。一、定义CountDownLatch的作用很简单，就是一个或者一组线程在开始执行操作之前，必须要等到其他线程执行完才可以。我们举一个例子来说明，在考试的时候，老师必须要等到所有人交了试卷才可以走。此时老师就相当于等待线程，而学生就好比是执行的线程。注意：j...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值