多线程同步与任务完成等待机制总结

原创 已于 2025-01-21 16:34:29 修改 · 置顶 · 1.5k 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #数据库 #开发语言
于 2025-01-14 11:28:42 首次发布

多线程同步与任务完成等待机制总结

在多线程编程中，合理的同步机制能够有效地协调多个线程之间的执行顺序，确保任务按照预期执行。常见的同步机制包括 CountDownLatch、CyclicBarrier、CompletableFuture、ExecutorService.invokeAll() 和 Phaser。接下来，我们将通过具体场景加伪代码示例来介绍这些同步工具的应用。

1. CountDownLatch

CountDownLatch 适用于多个线程执行任务，并在所有线程完成时执行后续操作的场景。

场景：

假设我们有一个数据处理系统，启动时需要从多个数据源加载数据，等待所有数据源加载完成后，再进行数据汇总。

伪代码：
// 初始化 CountDownLatch，等待的数据源数量为 5
CountDownLatch latch = new CountDownLatch(5);

// 启动 5 个线程，从不同的数据源加载数据
for (int i = 0; i < 5; i++) {
    executor.submit(() -> {
        loadDataFromSource();  // 从某个数据源加载数据
        latch.countDown();  // 完成任务，计数器减 1
    });
}

// 等待所有线程完成
latch.await();  // 阻塞直到所有线程执行完毕

// 所有数据加载完成后，执行数据汇总操作
aggregateData();
适用场景：
  • 任务依赖：多个线程执行，等所有线程完成后执行统一操作，如数据处理、汇总。
  • 资源管理：比如等待多个外部资源的加载（例如数据库连接、外部 API）。
示例代码：
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        // 初始化线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        // 初始化 CountDownLatch，等待 5 个数据源加载完成
        CountDownLatch latch = new CountDownLatch(5);

        // 启动 5 个线程，从不同的数据源加载数据
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                loadDataFromSource();  // 模拟从某个数据源加载数据
                latch.countDown();  // 每个线程完成任务，计数器减 1
            });
        }

        // 等待所有线程完成
        latch.await();  // 阻塞直到所有线程执行完毕

        // 所有数据加载完成后，执行汇总处理
        System.out.println("所有数据加载完成，开始数据汇总...");
        aggregateData();

        // 关闭线程池
        executor.shutdown();
    }

    private static void loadDataFromSource() {
        try {
            // 模拟加载数据的过程
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 数据加载完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void aggregateData() {
        // 数据汇总逻辑
        System.out.println("数据汇总完成");
    }
}
说明：
  • CountDownLatch 用来等待所有线程完成。latch.await() 会阻塞主线程，直到计数器归零。
  • 在所有线程完成任务后，主线程执行数据汇总操作。

2. CyclicBarrier

CyclicBarrier 适用于多个线程在某个同步点上等待，直到所有线程都到达同步点后一起继续执行。

场景：

假设我们有一个任务调度系统，需要定时对多个任务进行处理，并在每个调度周期结束时统一处理结果。

伪代码：
// 初始化 CyclicBarrier，等待 5 个线程
CyclicBarrier barrier = new CyclicBarrier(5, () -> {
    // 所有线程到达屏障点后执行的操作，如汇总处理结果
    processResults();
});

// 启动 5 个线程处理任务
for (int i = 0; i < 5; i++) {
    executor.submit(() -> {
        processTask();  // 处理任务
        barrier.await();  // 等待其他线程到达同步点
    });
}
适用场景：
  • 批处理任务：当多个任务需要并行执行，在每个周期结束时一起汇总。
  • 多阶段任务：多个任务按顺序执行，每个阶段结束时统一处理结果。
示例代码：
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierExample {

    public static void main(String[] args) throws InterruptedException {
        // 初始化线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 初始化 CyclicBarrier，等待 5 个线程完成
        CyclicBarrier barrier = new CyclicBarrier(5, () -> {
            // 所有线程到达屏障点后执行的操作
            System.out.println("所有线程到达同步点，开始汇总结果");
            processResults();
        });

        // 启动 5 个线程处理任务
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                processTask();  // 处理任务
                barrier.await();  // 等待其他线程到达同步点
            });
        }

        // 关闭线程池
        executor.shutdown();
    }

    private static void processTask() {
        try {
            // 模拟处理任务
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 任务处理完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void processResults() {
        // 汇总结果的逻辑
        System.out.println("所有任务处理完成，开始汇总结果");
    }
}
说明：
  • CyclicBarrier 用于多个线程在每个阶段同步。所有线程到达同步点后，主线程执行汇总操作。

3. CompletableFuture

CompletableFuture 用于处理异步任务，能够灵活地组合多个异步任务，并在任务完成时执行后续操作。

场景：

在一个数据同步系统中，需要从多个外部系统异步拉取数据，所有数据拉取完成后进行统一处理。

伪代码：
// 启动多个异步任务从不同系统拉取数据
CompletableFuture<Void>[] futures = new CompletableFuture[5];
for (int i = 0; i < 5; i++) {
    futures[i] = CompletableFuture.runAsync(() -> {
        fetchDataFromSystem();  // 从系统拉取数据
    });
}

// 等待所有异步任务完成
CompletableFuture.allOf(futures).join();

// 所有数据拉取完成后进行汇总处理
processFetchedData();
适用场景：
  • 异步数据处理：当多个任务并发执行，并希望在所有任务完成后执行后续操作。
  • 非阻塞任务：提高并发性，避免线程阻塞。
示例代码：
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 初始化线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 启动多个异步任务从不同系统拉取数据
        CompletableFuture<Void>[] futures = new CompletableFuture[5];
        for (int i = 0; i < 5; i++) {
            futures[i] = CompletableFuture.runAsync(() -> {
                fetchDataFromSystem();  // 异步从系统拉取数据
            }, executor);
        }

        // 等待所有异步任务完成
        CompletableFuture.allOf(futures).join();  // 阻塞，直到所有任务完成

        // 所有数据拉取完成后进行汇总处理
        System.out.println("所有数据拉取完成，开始数据汇总...");
        processFetchedData();

        // 关闭线程池
        executor.shutdown();
    }

    private static void fetchDataFromSystem() {
        try {
            // 模拟从外部系统拉取数据
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 数据拉取完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void processFetchedData() {
        // 数据汇总逻辑
        System.out.println("数据汇总完成");
    }
}
说明：
  • CompletableFuture 可以处理异步任务并在所有任务完成后执行后续操作，适合异步编程。

4. ExecutorService 的 invokeAll() 方法

invokeAll() 提交一组任务并阻塞直到所有任务完成，适用于需要处理多个任务并等待全部任务完成的场景。

场景：

在一个文件处理系统中，需要并行处理多个文件，确保所有文件都处理完再进行汇总操作。

伪代码：
// 创建一组任务
List<Callable<Void>> tasks = new ArrayList<>();
for (int i = 0; i < 5; i++) {
    tasks.add(() -> {
        processFile();  // 处理文件
        return null;
    });
}

// 提交任务并等待所有任务完成
executor.invokeAll(tasks);

// 所有任务完成后执行后续操作，如文件汇总
summarizeProcessedFiles();
适用场景：
  • 任务队列处理：多个任务并行执行，确保所有任务完成后再进行汇总或后续操作。
  • 并发任务管理：适用于已知所有任务并希望统一处理的场景。
示例代码：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ExecutorServiceInvokeAllExample {

    public static void main(String[] args) throws InterruptedException {
        // 初始化线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 创建一组任务
        List<Callable<Void>> tasks = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            tasks.add(() -> {
                processFile();  // 处理文件
                return null;
            });
        }

        // 提交任务并等待所有任务完成
        executor.invokeAll(tasks);

        // 所有任务完成后执行后续操作
        System.out.println("所有文件处理完成，开始汇总...");
        summarizeProcessedFiles();

        // 关闭线程池
        executor.shutdown();
    }

    private static void processFile() {
        try {
            // 模拟文件处理
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 文件处理完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void summarizeProcessedFiles() {
        // 文件汇总逻辑
        System.out.println("文件汇总完成");
    }
}
说明：
  • ExecutorService.invokeAll() 用于并行处理多个任务，并确保所有任务完成后执行后续操作。

5. Phaser

Phaser 提供了一种更加灵活的同步机制，支持多个阶段的任务同步，线程数也可以动态增加或减少。

场景：

在一个多阶段数据处理系统中，需要多个线程在每个阶段完成后同步进行下一阶段操作。

伪代码：
// 初始化 Phaser，指定等待线程数量为 5
Phaser phaser = new Phaser(5);

// 启动多个线程处理数据
for (int i = 0; i < 5; i++) {
    executor.submit(() -> {
        processStage1Data();  // 处理阶段 1 数据
        phaser.arriveAndAwaitAdvance();  // 等待其他线程完成阶段 1

        processStage2Data();  // 处理阶段 2 数据
        phaser.arriveAndAwaitAdvance();  // 等待其他线程完成阶段 2

        processStage3Data();  // 处理阶段 3 数据
        phaser.arriveAndDeregister();  // 完成最后一个阶段，注销线程
    });
}

// 等待所有线程完成所有阶段
phaser.awaitAdvance(phaser.getPhase());
适用场景：
  • 多阶段任务同步：在多个阶段中执行任务，确保所有线程完成一个阶段后进入下一阶段。
  • 线程数动态变化：适合线程数在不同阶段动态变化的场景。
示例代码：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Phaser;

public class PhaserExample {

    public static void main(String[] args) {
        // 初始化线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 初始化 Phaser，指定等待线程数量为 5
        Phaser phaser = new Phaser(5);

        // 启动多个线程处理任务
        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                processStage1Data();  // 处理阶段 1 数据
                phaser.arriveAndAwaitAdvance();  // 等待其他线程完成阶段 1

                processStage2Data();  // 处理阶段 2 数据
                phaser.arriveAndAwaitAdvance();  // 等待其他线程完成阶段 2

                processStage3Data();  // 处理阶段 3 数据
                phaser.arriveAndDeregister();  // 完成最后一个阶段，注销线程
            });
        }

        // 等待所有线程完成所有阶段
        phaser.awaitAdvance(phaser.getPhase());

        // 关闭线程池
        executor.shutdown();
    }

    private static void processStage1Data() {
        try {
            // 模拟阶段 1 数据处理
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 阶段 1 数据处理完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void processStage2Data() {
        try {
            // 模拟阶段 2 数据处理
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 阶段 2 数据处理完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void processStage3Data() {
        try {
            // 模拟阶段 3 数据处理
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 阶段 3 数据处理完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
说明：
  • Phaser 允许多个阶段的同步，在每个阶段完成时，线程等待并同步进入下一个阶段，适合需要多阶段任务的场景。

总结

在 Java 中，不同的同步工具有不同的适用场景。根据项目的具体需求，选择合适的同步机制能提高并发性能并避免线程安全问题。

  • CountDownLatch：用于等待所有线程完成，适合任务依赖的场景。
  • CyclicBarrier：适用于多线程到达某个同步点后一起继续执行，常用于周期性任务。
  • CompletableFuture：适用于处理异步任务，能灵活地组合任务。
  • ExecutorService.invokeAll()：适用于确保一组任务完成后执行汇总操作。
  • Phaser：适用于多阶段任务，并且支持线程动态变化的场景。

选择合适的同步工具能够提升并发效率，确保任务按预期执行。

CountDownLatch--等待多线程计数器
刘军的博客
05-21 2108
一、概述 CountDownLatch是什么？网上概念的描述太多了。其实个人理解，他就是--等待多线程计数器！ 即：在某线程中（主线程或其他分线程都可以）声明一个初始值为N的CountDownLatch计数器，然后等待多个子线程完成了相关操作后再继续向下执行。--当各子线程执行到相应的地方后使N-1，最后N=0时，线程不再等待，继续向下执行。 二、运用及场景 2.1、运用 Coun...
【线程池】线程池的使用案例
weixin_44823875的博客
03-20 9517
多线程-- 线程池（1）自定义线程池（2）java自带的线程池 （1）自定义线程池 （1）为什么使用线程池 每一个线程的启动和结束都是比较消耗时间和占用资源的。使用线程池的过程中创建固定数量的线程，不用创建多余新的线程，而是循环使用那些已经存在的线程。 （2）自定义线程池设计思路 1-准备一个任务容器 2-一次性启动10个消费者线程 3-刚开始任务容器是空的，所以线程都wait在上面 4-直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒 5-这个消费者线程取出“任务”，并且执行这
CountdownLatch详解
清风不灭的博客
03-07 1万+
文章转载自：https://segmentfault.com/a/1190000016508108 CountdownLatch CountDownLatch本身是基于共享锁实现的，该工具是为了解决某些操作只能在一组操作全部执行完成后才能执行的情景CountDown是倒数计数，所以CountDownLatch的用法通常是设定一个大于0的值，该值即代表需要等待的总任务数，每完成一个任务后，将总任...
Latch 设计模式
实践求真知
04-26 2074
一点睛 若干个线程并发执行某个特定的任务，然后等到所有的子任务都执行结束后在统一汇总，比如用户想要查询自己三年以来银行账户的流水，为了保证运行的数据库的数据量在一个恒定的范围之内，通常数据只会保存一年的记录，其他历史记录或被备份到磁盘，或者被存储到hive数据仓库，或者被转至备份数据库之中，总之，想要三年的流水记录，需要若干次的查询最后汇总返回给用户，很明显这样的操作性能低下，用户体验差，如果我们将每一个渠道的查询交给一个线程或者若干干线程去查询，然后统一汇总，那么性能会提高很多，响应时间也会缩短不...
java中的多线程实现
ZMyths的博客
01-19 844
最近因为业务原因，一个接口不同的字段都要调不同的服务来拿，串行调用肯定会超时。那么只有通过异步调用或者多线程来实现。于是把五花八门的多种实现方式整理了一下。 1.继承Thread 类，实现run 方法 。 用start方法启动 package com.dianping.cip.region.biz.utils; public class ThreadDemo extends Thread ...
JUC中等待多线程完成的工具类CountDownLatch，必备技能
weixin_45653328的博客111
12-03 1008
CountDownLatch称之为闭锁，它可以使一个或一批线程在闭锁上等待，等到其他线程执行完相应操作后，闭锁打开，这些等待的线程才可以继续执行。确切的说，闭锁在内部维护了一个倒计数器。通过该计数器的值来决定闭锁的状态，从而决定是否允许等待的线程继续执行。常用方法：public CountDownLatch(int count)：构造方法，count表示计数器的值，不能小于0，否者会报异常。
[Java][Android] 多线程同步-主线程等待所有子线程完成案例
QiuJuer
06-26 7088
有时候我们会遇到这样的问题：做一个大的事情可以被分解为做一系列相似的小的事情，而小的事情无非就是参数上有可能不相同而已！ 此时，如果不使用线程，我们势必会浪费非常多的时间来完成整个大的事情，而使用线程的话将会存在这样的问题： 主线程启动所有子线程并发执行后主线程就直接返回了，导致外部函数判读整个大的事情完成了，但是实际上并没有完成！ 针对以上情况我想我会采用多线程方式执行同时解决主线
linux同步机制-complete
DSP小胖的博客
03-29 2394
linux驱动程序中可以使用的同步机制有很多，这里只介绍complete机制。 1. 什么是complete? completion，它用于一个执行单元等待另一个执行单元执行完某事。Linux系统中与completion相关的操作主要有以下4种: (1) 定义completion struct completion my_completion; (2) 初始化completion init_completion(&my_...
Java等待通知机制比较（wait，notify，notifyAll；CountDownLatch；Condition）
xqqTechnology的博客
05-27 539
@[TOC](wait，notify，notifyAll；CountDownLatch；Condition原理和解析） #在Java多线程开发中，涉及到线程之间的协作，配合。为了满足不同场景的开发需求，Java也提供了多种方式供开发人员选择。 part1：wait，notify，notifyAll 首先可以看一下这三个方法的源码位置， 从源码我们可以知道，这三个方法都是java的最顶层的类Object的方法，并且是native方法，也就是说着三个方法执行时需要对象级别的锁，在调用 wait （） 、no
介绍几种等待多线程任务执行完毕的方法
liuqinhou的博客
10-12 2726
java 多线程
latch.await java有什么作用_CountDownLatch源码解析之await()
weixin_34966346的博客
02-27 2221
CountDownLatch 源码解析—— await()，具体内容如下上一篇文章说了一下CountDownLatch的使用方法。这篇文章就从源码层面说一下await() 的原理。我们已经知道await 能够让当前线程处于阻塞状态，直到锁存器计数为零(或者线程中断)。下面是它的源码。end.await();↓public void await() throws InterruptedExcepti...
等待多个线程执行完成后再运行的几种方式
dream_xin2013的专栏
11-03 5553
介绍在使用多线程过程中，需要等待多个线程执行完后再执行主线程的几种实现方式，提升系统性能
多线程如何等待所有子线程一起完成任务后再执行主线程
weixin_44860609的博客
01-08 4328
多线程如何等待所有子线程一起完成任务后再执行主线程 1、使用线程类自带的join方法，将子线程加入到主线程，在子线程执行完之后，在执行主线程逻辑。 public static void joinDemo() throws InterruptedException { System.out.println("=========Test with join====="); JoinWorker worker1 = new JoinWorker("worke
并发编程工具类-CountDownLatch的使用和原理解析
stay hungry,stay foolish!
06-07 940
1、CountDownLatch 概念 CountDownLatch可以使一个获多个线程等待其他线程各自执行完毕后再执行。 CountDownLatch 定义了一个计数器，和一个阻塞队列， 当计数器的值递减为0之前，阻塞队列里面的线程处于挂起状态，当计数器递减到0时会唤醒阻塞队列所有线程，这里的计数器是一个标志，可以表示一个任务一个线程，也可以表示一个倒计时器，CountDownLatch可以解决那些一个或者多个线程在执行之前必须依赖于某些必要的前提业务先执行的场景。 2、CountDownLatch 常用
java countdownlatch_并发工具类（一）等待多线程完成的CountDownLatch
weixin_35867994的博客
02-21 267
简介CountDownLatch 允许一个或多个线程等待其他线程完成操作。应用场景假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完成。在这个需求中，要实现主线程等待所有线程完成sheet的解析操作，最简单的做法是使用join。代码如下：public class Jo...
多线程返回值的例子
爱健身的小刘
09-03 1万+
当我们面临大量数据查询的时候，在我有限的技术生涯中，想到两种解决方案。 1.建立专业的solr查询引擎，实现全文检索。 2.多线程加速查询的过程。   后台管理系统，数据量不算大，但是来源较多。较杂。 目前的处理方式是用多线程实现。   那么，问题来了，多线程的查询，关键问题在于，传递了参数，如何将查询出的结果返回。   解决方案是采用Callable：   一、一个简单的d...
CountDownLatch详解
热门推荐
抽象的螺旋
11-04 2万+
概述 CountDownLatch概念 CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，用来作为线程间的通信而不是互斥作用。 CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。 使用一个计数器进行实现，计数器初始值就是线程的数量。 当每个被计数的线程完成任务后，计数器值减一，当计数器的值为0时，表示所有线程都已经完成了任务，然后在CountDownLatch上等待的线程就可以恢复执行。 CountDownLatch的用法 ...
SpringBoot2.x+Spring5+Mybits3.x后期使用vue前端构建前后端分离-13 定时任务和异步任务
qq_41525746的博客
11-09 590
什么是定时任务和常见定时任务区别 什么是定时任务，使用场景 某个时间定时处理某个任务 发邮件、短信等 消息提醒 订单通知 统计报表系统 --每天的访问的量订单等 .... 常见定时任务 Java自带的java.util.Timer类配置比较麻烦，时间延后问题 Quartz框架: 配置更简单,xml或者注解适合分布式或者大型调度作业 SpringBoot框架自带 SpringBoot使用注解方式开启定时任务 启动类里面 @EnableScheduling开启定时任务，定时自动扫描 定时
Java 的 CountDownLatch 中，latch.await()的作用是什么，怎么使用的
最新发布
qq_44313636的博客
08-13 510
Java 的 CountDownLatch 中，latch.await() 是怎么使用的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值