public static class SelectMaxProblem {
private final int[] numbers;
private final int start;
private final int end;
public final int size;
// constructors elided
public SelectMaxProblem(int[] numbers, int start, int end) {
this.numbers = numbers;
this.start = start;
this.end = end;
this.size = end - start;
}
public int solveSequentially() {
int max = Integer.MIN_VALUE;
for (int i=start; i<end; i++) {
int n = numbers[i];
if (n > max)
max = n;
}
return max;
}
public SelectMaxProblem subproblem(int subStart, int subEnd) {
return new SelectMaxProblem(numbers, start + subStart,
start + subEnd);
}
@Override
public String toString() {
return String.format("P{start:%2s, end:%2s}",start,end);
}
}
public static class MaxWithFJ extends RecursiveAction {
private final int threshold;
private final SelectMaxProblem problem;
public int result;
public MaxWithFJ(SelectMaxProblem problem, int threshold) {
this.problem = problem;
this.threshold = threshold;
}
protected void compute() {
String pre = problem.toString();
if (problem.size < threshold) {
result = problem.solveSequentially();
print(pre,"return result:"+result);
}else {
int midpoint = problem.size / 2;
SelectMaxProblem leftProblem = problem.subproblem(0, midpoint);
SelectMaxProblem rightProblem = problem.subproblem(midpoint + 1, problem.size);
MaxWithFJ left = new MaxWithFJ(leftProblem, threshold);
MaxWithFJ right = new MaxWithFJ(rightProblem, threshold);
print(pre,leftProblem + "|" + rightProblem);
left.fork();
right.fork();
print(pre,"fork");
print(pre,"begin left join");
left.join();
print(pre,"after left join.begin rigth join");
right.join();
print(pre,"join");
result = Math.max(left.result, right.result);
}
}
public static void main(String[] args) {
int size = 40;
int[] numbers = new int[size];
for (int i = 0; i < size; i++) {
numbers[i] = i;
}
SelectMaxProblem problem = new SelectMaxProblem(numbers,0,numbers.length);
int threshold = 10;
int nThreads = 2;
MaxWithFJ mfj = new MaxWithFJ(problem, threshold);
ForkJoinPool fjPool = new ForkJoinPool(nThreads);
fjPool.invoke(mfj);
int result = mfj.result;
print("main",result);
}
static void print(String pre,Object object) {
Thread thread = Thread.currentThread();
String msg = String.format("Thread[%s] %s > %s", thread.getId(), pre, object);
System.out.println(msg);
}
}
输出结果:
Thread[11] P{start: 0, end:40} > P{start: 0, end:20}|P{start:21, end:40}
Thread[11] P{start: 0, end:40} > fork
Thread[11] P{start: 0, end:40} > begin left join
Thread[12] P{start: 0, end:20} > P{start: 0, end:10}|P{start:11, end:20}
Thread[12] P{start: 0, end:20} > fork
Thread[12] P{start: 0, end:20} > begin left join
Thread[13] P{start:21, end:40} > P{start:21, end:30}|P{start:31, end:40}
Thread[13] P{start:21, end:40} > fork
Thread[13] P{start:21, end:40} > begin left join
Thread[12] P{start: 0, end:10} > P{start: 0, end: 5}|P{start: 6, end:10}
Thread[13] P{start:21, end:30} > return result:29
Thread[12] P{start: 0, end:10} > fork
Thread[13] P{start:21, end:40} > after left join.begin rigth join
Thread[12] P{start: 0, end:10} > begin left join
Thread[12] P{start: 0, end: 5} > return result:4
Thread[13] P{start:31, end:40} > return result:39
Thread[12] P{start: 0, end:10} > after left join.begin rigth join
Thread[13] P{start:21, end:40} > join
Thread[12] P{start: 6, end:10} > return result:9
Thread[13] P{start:11, end:20} > return result:19
Thread[12] P{start: 0, end:10} > join
Thread[12] P{start: 0, end:20} > after left join.begin rigth join
Thread[12] P{start: 0, end:20} > join
Thread[11] P{start: 0, end:40} > after left join.begin rigth join
Thread[11] P{start: 0, end:40} > join
Thread[1] main > 39
说明:
1.RecursiveAction#fork代表用新的线程来执行
2.RecursiveAction#join会让当前线程开始等待.这里和普通的Thread#join的区别是,线程在调用join函数时,会去执行别的任务.可以从输出看到编号12和13的线程,join后再执行子任务.
分享到:
相关推荐
标题“Fork/Join例子”暗示我们将探讨一个具体的示例,展示如何使用这个框架来解决问题。通常,这样的例子会涵盖创建自定义的`RecursiveTask`或`RecursiveAction`类,以及如何使用`ForkJoinPool`来执行它们。 描述...
ForkJoin并发框架是Java 7引入的一种高效并行计算框架,它基于分而治之(Divide and Conquer)的策略,适用于处理大量可分割的任务。这个框架的核心类是`ForkJoinPool`和`ForkJoinTask`,它们为开发者提供了创建和...
虽然对于商品详情页面展示这个特定例子,直接使用线程池可能已经足够,但在处理更大规模、更复杂的问题时,ForkJoin框架能带来显著的性能提升。通过学习和熟练运用ForkJoin,开发者可以构建出更加灵活、高效的并发...
下面是一个简单的ForkJoin框架的应用示例,该示例展示了如何使用ForkJoin框架来计算一组数字的总和: ```java public class ForkJoinDemo extends RecursiveTask<Long> { private Long start; private Long end; ...
Fork/Join框架是Java并发处理的一个重要工具,它基于工作窃取算法,设计用于高效地执行并行计算任务。这个框架是Java 7引入的,位于`java.util.concurrent.fork/join`包中,目的是简化多核处理器环境下大规模数据...
快速排序是一个经典的适合使用Fork/Join框架的例子。首先创建一个`RecursiveTask`来表示排序任务,任务会检查数组的大小,如果数组元素少于某个阈值,就直接排序(递归结束条件);否则,将数组一分为二,分别创建两...
JDK 7 中引入的 Fork/Join 模式是一种基于分治策略的并行编程模型,旨在简化在多核处理器环境下实现高效的并行计算。这一模式的核心思想是将复杂的大任务拆分成一系列小任务,然后将这些小任务并行执行,最后再合并...
Fork/Join框架是Java SE 7引入的一项重要技术,它使得编写高效、并行的程序变得更加容易。本文将简要回顾Java中的并发编程基础知识,介绍java.util.concurrent包提供的高级并发原语,并深入探讨Fork/Join框架及其在...
Java的Fork/Join框架是Java 7引入的一个并行计算工具,它是基于分而治之(Divide and Conquer)策略的。该框架旨在简化并行编程,尤其是在多核处理器环境中提高性能。Fork/Join框架的核心类包括`ForkJoinPool`和`...
否则,任务会被拆分为两个子任务,分别处理数组的一半,然后将两个子任务的结果相加,这就是fork和join的过程。 在实际使用ForkJoinPool时,我们可以通过submit方法提交任务: ```java ForkJoinPool pool = new ...
Java Fork/Join框架是Java 7引入的一种并行计算模型,设计目的是为了高效地处理大量数据,尤其是在多核处理器环境中。该框架的核心理念是通过将复杂的大任务分解为多个小任务,然后并行执行这些小任务,从而加速计算...
一个最简单的例子是使用 Fork/Join 框架来求一个数组中的最大/最小值,这个任务就可以拆成很多小任务,大任务就是寻找一个大数组中的最大/最小值,我们可以将一个大数组拆成很多小数组,然后分别求解每个小数组中的...
下面是一个简单的Fork/Join框架的例子,假设我们要计算一个数组的累加和: ```java import java.util.concurrent.ForkJoinPool; import java.util.concurrent.RecursiveAction; public class SumCalculator ...
工作流入门必经的四个简单例子。 vacate主要说明基本使用。...ForkJoin主要说明Fork结点和Join结点的使用。 countersignature主要说明如何持久化和实现较复杂的task node控制, 其中还包括如何monitor你的jBPM。
JoinAndForkUtility 可轻松使用 java 7 中的 join 和 fork 功能的实用程序类。 易于使用并提高耗时 for 循环的性能。 更多的是尝试将 fork/join/compute 方法等与业务问题分离。用法如果您必须为大量对象循环耗时的...
7. **熔断与容错(Failsafe & Fallback)**:Dubbo提供了熔断和容错机制,如Hystrix、ForkJoin等,以防止服务雪崩,提高系统稳定性。 8. **服务监控(Monitoring)**:Dubbo内置了监控统计功能,可以收集服务调用的...
Fork-Join 框架提供了一些核心类和接口来支持这种模式,主要包括 `ForkJoinPool`(管理任务执行)、`RecursiveAction`(无返回值的任务类型)、`RecursiveTask`(有返回值的任务类型)等。 例如,下面是一个简单...
前面提到的例子仅适用于Unix/Linux环境。对于Windows环境,可以使用`multiprocessing`模块来实现多进程。 ```python from multiprocessing import Process def run_proc(name): print('Run child process %s (%s)...
多线程的Fork/Join框架,提升并行计算性能;以及更强大的类型推断等。虽然现在JDK已经有了更高的版本,但在某些场景下,比如兼容旧系统,仍会选择使用JDK1.7。 **Tomcat8** 是一个开源的Servlet容器,实现了Java ...
1. **活动图的基本元素**:活动图由几个基本元素构成,包括活动(Activity)、泳道(Swimlane)、决策/合并节点(Decision/Merge Node)、分支(Fork/Join)、初始节点(Initial Node)、终止节点(Final Node)和...