面试官:如何实现线程池任务编排?

简介: 面试官:如何实现线程池任务编排?

任务编排(Task Orchestration)是指管理和控制多个任务的执行流程,确保它们按照预定的顺序正确执行

1.为什么需要任务编排?

在复杂的业务场景中,任务间通常存在依赖关系,也就是某个任务会依赖另一个任务的执行结果,在这种情况下,我们需要通过任务编排,来确保任务按照正确的顺序进行执行。

例如,以下任务的执行顺序:

其中,任务二要等任务一执行完才能执行,而任务四要等任务二和任务三全部执行完才能执行。

2.任务编排实现

任务编排和控制的主要手段有以下:

  • Future
  • CompletableFuture
  • CountDownLatch
  • Semaphore
  • CyclicBarrier

但如果是全局线程池,想要实现精准的任务编排,只能使用 Future 或 CompletableFuture。

2.1 Future 任务编排

使用 Future 实现上述 4 个任务的编排(任务二要等任务一执行完才能执行,而任务四要等任务二和任务三全部执行完才能执行):

import java.util.concurrent.*;
import java.util.Arrays;

public class TaskOrchestrator {
   
   
    public static void main(String[] args) {
   
   
        // 创建一个线程池来执行任务
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 定义任务一
        Future<String> taskOneResult = executor.submit(new Callable<String>() {
   
   
            @Override
            public String call() throws Exception {
   
   
                Thread.sleep(2000); // 模拟耗时操作
                return "Task One Result";
            }
        });

        // 定义任务二,依赖任务一
        Future<String> taskTwoResult = executor.submit(new Callable<String>() {
   
   
            @Override
            public String call() throws Exception {
   
   
                String result = taskOneResult.get(); // 阻塞等待任务一完成
                Thread.sleep(1000); // 模拟耗时操作
                return "Task Two Result, got: " + result;
            }
        });

        // 定义任务三
        Future<String> taskThreeResult = executor.submit(new Callable<String>() {
   
   
            @Override
            public String call() throws Exception {
   
   
                Thread.sleep(1500); // 模拟耗时操作
                return "Task Three Result";
            }
        });

        // 定义任务四,依赖任务二和任务三
        Future<String> taskFourResult = executor.submit(new Callable<String>() {
   
   
            @Override
            public String call() throws Exception {
   
   
                String taskTwoOutput = taskTwoResult.get(); // 阻塞等待任务二完成
                String taskThreeOutput = taskThreeResult.get(); // 阻塞等待任务三完成
                Thread.sleep(500); // 模拟耗时操作
                return "Task Four Result, got: " + taskTwoOutput + " and " + taskThreeOutput;
            }
        });

        // 打印最终结果
        try {
   
   
            System.out.println("Final Result: " + taskFourResult.get());
        } catch (InterruptedException | ExecutionException e) {
   
   
            e.printStackTrace();
        }
    }
}

2.2 CompletableFuture 任务编排

CompletableFutrue 提供的方法有很多,但最常用和最实用的核心方法只有以下几个:

接下来,使用 CompletableFuture 实现上述 4 个任务的编排(任务二要等任务一执行完才能执行,而任务四要等任务二和任务三全部执行完才能执行):

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
   
   

    public static void main(String[] args) {
   
   
        // 任务一:返回 "Task 1 result"
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
   
   
            try {
   
   
                // 模拟耗时操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
   
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 1 result";
        });
        // 任务二:依赖任务一,返回 "Task 2 result" + 任务一的结果
        CompletableFuture<String> task2 = task1.handle((result1, throwable) -> {
   
   
            try {
   
   
                // 模拟耗时操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
   
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 2 result " + result1;
        });
        // 任务三:和任务一、任务二并行执行,返回 "Task 3 result"
        CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> {
   
   
            try {
   
   
                // 模拟耗时操作
                Thread.sleep(800); // 任务三可能比任务二先完成
            } catch (InterruptedException e) {
   
   
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 3 result";
        });
        // 任务四:依赖任务二和任务三,等待它们都完成后执行,返回 "Task 4 result" + 任务二和任务三的结果
        CompletableFuture<String> task4 = CompletableFuture.allOf(task2, task3).handle((res, throwable) -> {
   
   
            try {
   
   
                // 这里不需要显式等待,因为 allOf 已经保证了它们完成
                return "Task 4 result with " + task2.get() + " and " + task3.get();
            } catch (InterruptedException | ExecutionException e) {
   
   
                throw new RuntimeException(e);
            }
        });
        // 获取任务四的结果并打印
        String finalResult = task4.join();
        System.out.println(finalResult);
    }
}

课后思考

Future 和 CompletableFutrue 有什么关系?CompletableFutrue 底层是如何实现的?

本文已收录到我的面试小站 www.javacn.site,其中包含的内容有:Redis、JVM、并发、并发、MySQL、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、设计模式、消息队列等模块。

相关文章
|
27天前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇(2023版)
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合?ConcurrentHashMap、JUC
【Java面试题汇总】多线程、JUC、锁篇(2023版)
|
28天前
|
消息中间件 前端开发 NoSQL
面试官:线程池遇到未处理的异常会崩溃吗?
面试官:线程池遇到未处理的异常会崩溃吗?
62 3
面试官:线程池遇到未处理的异常会崩溃吗?
|
29天前
|
消息中间件 存储 前端开发
面试官:说说停止线程池的执行流程?
面试官:说说停止线程池的执行流程?
38 2
面试官:说说停止线程池的执行流程?
|
2月前
|
Java
【多线程面试题二十五】、说说你对AQS的理解
这篇文章阐述了对Java中的AbstractQueuedSynchronizer(AQS)的理解,AQS是一个用于构建锁和其他同步组件的框架,它通过维护同步状态和FIFO等待队列,以及线程的阻塞与唤醒机制,来实现同步器的高效管理,并且可以通过实现特定的方法来自定义同步组件的行为。
【多线程面试题二十五】、说说你对AQS的理解
|
2月前
|
消息中间件 缓存 算法
Java多线程面试题总结(上)
进程和线程是操作系统管理程序执行的基本单位,二者有明显区别: 1. **定义与基本单位**:进程是资源分配的基本单位,拥有独立的内存空间;线程是调度和执行的基本单位,共享所属进程的资源。 2. **独立性与资源共享**:进程间相互独立,通信需显式机制;线程共享进程资源,通信更直接快捷。 3. **管理与调度**:进程管理复杂,线程管理更灵活。 4. **并发与并行**:进程并发执行,提高资源利用率;线程不仅并发还能并行执行,提升执行效率。 5. **健壮性**:进程更健壮,一个进程崩溃不影响其他进程;线程崩溃可能导致整个进程崩溃。
38 2
|
2月前
|
存储 安全 容器
【多线程面试题二十一】、 分段锁是怎么实现的?
这篇文章解释了分段锁的概念和实现方式,通过将数据分成多个段并在每段数据上使用独立锁,从而降低锁竞争,提高并发访问效率,举例说明了`ConcurrentHashMap`如何使用分段锁技术来实现高并发和线程安全。
【多线程面试题二十一】、 分段锁是怎么实现的?
|
2月前
|
安全 Java
【多线程面试题十九】、 公平锁与非公平锁是怎么实现的?
这篇文章解释了Java中`ReentrantLock`的公平锁和非公平锁的实现原理,其中公平锁通过检查等待队列严格按顺序获取锁,而非公平锁允许新线程有更高机会立即获取锁,两者都依赖于`AbstractQueuedSynchronizer`(AQS)和`volatile`关键字以及CAS技术来确保线程安全和锁的正确同步。
【多线程面试题十九】、 公平锁与非公平锁是怎么实现的?
|
2月前
|
存储 缓存 安全
Java多线程面试题总结(中)
Java内存模型(JMM)定义了程序中所有变量的访问规则与范围,确保多线程环境下的数据一致性。JMM包含主内存与工作内存的概念,通过8种操作管理两者间的交互,确保原子性、可见性和有序性。`synchronized`和`volatile`关键字提供同步机制,前者确保互斥访问,后者保证变量更新的可见性。多线程操作涉及不同状态,如新建(NEW)、可运行(RUNNABLE)等,并可通过中断、等待和通知等机制协调线程活动。`volatile`虽不确保线程安全,但能确保变量更新对所有线程可见。
18 0
|
2月前
|
Java 程序员 容器
【多线程面试题二十四】、 说说你对JUC的了解
这篇文章介绍了Java并发包java.util.concurrent(简称JUC),它是JSR 166规范的实现,提供了并发编程所需的基础组件,包括原子更新类、锁与条件变量、线程池、阻塞队列、并发容器和同步器等多种工具。
|
2月前
|
缓存 Java
【多线程面试题二十三】、 说说你对读写锁的了解volatile关键字有什么用?
这篇文章讨论了Java中的`volatile`关键字,解释了它如何保证变量的可见性和禁止指令重排,以及它不能保证复合操作的原子性。