Java 中 Fork/Join 框架和 ExecutorService 的区别

2025年3月17日 | 阅读 7 分钟

在 Java 中，**Fork/Join** 框架主要用于提供与并行处理和编程相关的功能，它通过将一个操作分解为更小的操作或指令，并利用可用的 CPU 核心进行处理来实现。

类似地，Java 中的 **ExecutorService** 可以定义为一个接口，负责提供用于管理和控制线程的替代方案。**java.util.concurrent** 包负责存储 Java 中的 **ExecutorService** 接口。**java.util.concurrent** 包在 Java 5 中发布。

Java 中的 Fork/Join 框架

Java 的 Fork/Join 框架主要用于提供与执行任务框架相关的特性和功能，以获得最佳性能。并行计算引擎主要用于许多高级框架。Fork/Join 框架支持并行编程，这在用分而治之技术解决问题时非常有用。问题可以使用分而治之技术以以下方式解决：

一个任务将被分解或拆分成多个子任务。
所有子任务将并行解决。
1. 可以使用多个核心以并行方式运行各个子任务。
2. 单个核心可以并发地在不同线程中运行或执行多个子任务。
等待状态，直到所有子任务完全执行完毕。
生成的结果将被合并或分组在一起。

让我们通过一个 Java 示例程序来详细了解 Java 中 Fork/Join 框架的特性和功能。

文件名： ForkAndJoin.java

// Java program for demonstrating the features and functionalities of Fork and Join Framework.
import java.io.*;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
class FindTask extends RecursiveTask<Integer> {
// Variables which are Non-static or instance.
int Arr[];
int first, last;
int target_Element;
// Initialization of Non static variables through constructor.
public FindTask(int Arr[], int first, int last,int target_Element)
{
// This Keyword is utilized for refering to the same instance of the object.
this.Arr = Arr;
this.first = first;
this.last = last;
this.target_Element = target_Element;
}
protected Integer compute()
{
// The Result is calculated and returned.
return Find_Process();
}
// Method that returns the count of a target element required.-
private Integer Find_Process()
{
// count variable is initialized with 0 value.
int cnt = 0;
for (int i = first; i <= last; i++) {
// Condition when target element is available in the Array of integers.
if (Arr[i] == target_Element) {
//The count value gets incremented.
cnt++;
}
}
// Returns the count value calculated of the target value provided.
return cnt;
}
}
public class ForkAndJoin{
public static void main(String args[])
{
// Declaring and initializing the integer array with random values.
int Arr[] = { 1 ,2 , 3 , 4 , 5, 5, 6 , 7, 8, 12, 11, 11, 1, 1, 1, 1, 2, 3, 8, 9};
// Target element whose count must be calculated.
int target_Element = 1;
// The First and Last variables being declared and initialized.
int first = 0;
int last = Arr.length - 1;
// The Object of ForkJoinPool is being created.
ForkJoinPool fork_join_pool = ForkJoinPool.commonPool();
// Object creation of above-mentioned class.
FindTask ans = new FindTask(Arr, first, last, target_Element);
int answer = fork_join_pool.invoke(ans);
// Calculates and displays the occurence of the target element, if not available displays the message.
System.out.println("The occurence of the Target element " +target_Element + " is " + answer + " times ");
}
}

输出

Difference Between Fork/Join Framework and ExecutorService in Java

Java 中的 ExecutorService

在 Java 中，ExecutorService 主要用于管理和控制所有异步任务的顺序和执行，这些任务有时被称为 Runnable 和 Callable 接口的实例。任务可以提交到 **ExecutorService**，而无需直接处理线程。提交给 ExecutorService 的任务将由它负责线程管理。

让我们通过一个 Java 示例程序来详细了解 Java 中的 ExecutorService。

文件名： ExecutorServiceExample.java

// Java program for demonstration of features and functionalities of ExecutorService.
import java.io.*;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
// This class extends the Runnable interface.
class Process implements Runnable {
// Non static or Instance variable of the above-mentioned class.
int I;
// Constructor of the above-mentioned class.
public Process(int I)
{
// Initialization of the non static or instance variable.
this.I = I;
}
public void run()
{
// Displaying the Counter.
System.out.println(I + " ");
// Using the block keyword for checking any exceptions.
try {
// The thread will be made to sleep for 1 second with the help of sleep() method.
Thread.sleep(1000);
}
// Using the catch block for catching the exceptions.
catch (InterruptedException e) {

// Displaying the line of error or exception and the message with it.
e.printStackTrace();
}
}
}
public class ExecutorServiceExample {
public static void main(String[] args)
{
// A fixed size thread pool gets created by creating object of the ExecutorServiceExample class.
ExecutorService ob1 = Executors.newFixedThreadPool(5);
// Displays the current time before execution.
System.out.println(new Date());
for (int I = 0; I < 25; I++) {
// This statement gets executed in the future.
ob1.execute(new Process(I));
}
//The executor get shut down so that the main task is considered to be completed.
ob1.shutdown();
// Displays the time after completion of task.
System.out.println(new Date());
}
}

输出

让我们通过另一个示例程序来了解 Java 中 Fork/Join 框架和 ExecutorService 的特性和功能。

示例 2

文件名： ForkJoinExecutorService.java

// Java program for demonstrating the implementation of Fork and Join framework and ExecutorService in Java.
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Callable;
import java.util.ArrayList;
import java.util.List;
class AddTask extends RecursiveTask<Long> {
    private static final int threshold = 5; // Threshold for splitting the task
    private int[] arr;
    private int first;
    private int last;
    public AddTask(int[] arr, int first, int last) {
        this.arr = arr;
        this.first = first;
        this.last = last;
    }
    @Override
    protected Long compute() {
        if ((last - first) <= threshold) {
            return compute_InOrder();
        } else {
            int mid = first + (last - first) / 2;
            AddTask left_task = new AddTask(arr, first, mid);
            AddTask right_task = new AddTask(arr, mid, last);
            left_task.fork(); // Fork the left task
            long rightResult = right_task.compute(); // Compute the right task immediately
            long leftResult = left_task.join(); // Join the result of the left task
            return leftResult + rightResult;
        }
    }
    private long compute_InOrder() {
        long sum = 0;
        for (int i = first; i < last; i++) {
            sum += arr[i];
        }
        return sum;
    }
}
public class ForkJoinExecutorService {
    public static void main(String[] args) {
        int[] arr = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
        // Utilizing Fork/Join framework. 
        ForkJoinPool Fork_Join_Pool = ForkJoinPool.commonPool();
        long forkJoinResult = Fork_Join_Pool.invoke(new AddTask(arr, 0, arr.length));
        System.out.println("Result Obtained By Fork/Join Framework: " + forkJoinResult);
        // Utlizing ExecutorService
        ExecutorService executor_Service = Executors.newFixedThreadPool(4);
        List<Callable<Long>> main_tasks = new ArrayList<>();
        int chunk_size = arr.length / 4; // Split the arr into 4 chunks
        for (int i = 0; i < 4; i++) {
            int first = i * chunk_size;
            int last = (i == 3) ? arr.length : (i + 1) * chunk_size;
            main_tasks.add(() -> {
                long sum = 0;
                for (int j = first; j < last; j++) {
                    sum += arr[j];
                }
                return sum;
            });
        }
        try {
            long executorServiceResult = executor_Service.invokeAll(main_tasks)
                    .stream()
                    .mapToLong(future -> {
                        try {
                            return future.get();
                        } catch (InterruptedException | ExecutionException e) {
                            throw new RuntimeException(e);
                        }
                    })
                    .sum();
            System.out.println("Result Obtained By ExecutorService:  " + executorServiceResult);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executor_Service.shutdown();
        }
    }
}

输出

Result Obtained By Fork/Join Framework: 120
Result Obtained By ExecutorService:  120

Java 中 Fork/Join 与 ExecutorService 的区别

让我们通过一个表格来了解 Java 中 Fork/Join 框架与 ExecutorService 的主要区别。

Fork/Join 框架	ExecutorService
Java 7 中的 Fork/Join 框架可以定义为一个实现，它遵循分而治之的算法。分支的 ForkJoinTasks 通过一个中央 ForkJoinPool 来执行。	在 Java 中，ExecutorService 可以定义为一个执行器，负责提供用于管理、跟踪进度和停止异步任务的方法和函数。
Fork/Join 框架利用或实现了工作窃取算法。当一个进程或任务依赖于使用 join 操作创建的其他子任务的完成时，当前执行任务的工作线程将查找尚未执行的其他任务，并借用它们来执行。	而在 ExecutorService 中，当一个进程或任务在等待使用 join 操作创建的另一个子任务完成执行时，负责执行该线程的线程不会借用其他待处理任务来执行。
在 Java 中，Fork/Join 框架主要用于解决与递归相关的问题，以及在需要子任务运行子任务然后处理其结果的情况下。	与 Fork/Join 框架不同，Java 中的 ExecutorService 不能用来解决与递归相关的问题。因为这会导致线程被占用并等待其他线程的结果。
换句话说，Java 中的 Fork/Join 框架是通过 Java 中的 ExecutorService 实现的。唯一的主要区别可以解释为 Fork/Join 框架的实现负责创建一个 DEQUE 工作池。	可以使用 ExecutorService 创建所需数量的线程。类似地，应用了一个阻塞队列，用于存储所有处于等待状态的剩余任务。

下一主题Java 中局部变量、实例变量和静态变量的区别

Java 中 Fork/Join 框架和 ExecutorService 的区别

Java 中的 Fork/Join 框架

Java 中的 ExecutorService

Java 中 Fork/Join 与 ExecutorService 的区别

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中 Fork/Join 框架和 ExecutorService 的区别

Java 中的 Fork/Join 框架

Java 中的 ExecutorService

Java 中 Fork/Join 与 ExecutorService 的区别

相关帖子

Java 中数组转字符串

Java 函数

Identifiers in Java

Java 中不使用除法（/）运算符进行除法

Java 中的等比数列第 N 项

Java 中的 ConcurrentSkipListSet

Java 中的猪游戏

Java 中变量的生命周期

Java 中的 OffsetDateTime format() 方法及示例

Java 中的 Bully 算法

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器