1、
package multiThread.art;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
/**
* 需求是: 计算 1+2+3+4 的结果
* 分割上面的计算任务,并希望每个子任务最多执行两个数的相加
*
* 1)RecursiveTask 是 ForkJoinTask 的子类
* 2) ForkJoinTask 与一般任务的主要区别在于: 它需要实现 compute 方法。
* 3) compute 方法,首先需要判断任务是否足够小,如果足够小就直接执行任务。
* 如果不够小,就必须分割成两个子任务,每个子任务在调用 fork()方法的时候,
* 又会进入 compute() 方法,看看当前子任务是否需要继续分割成子任务,如果不需要
* 继续分割,则执行当前任务并返回结果
* 4) 使用 join 方法会等待子任务执行完并得到其结果。
*/
public class CountTask extends RecursiveTask<Integer> {
/**
* 阀值
*/
private static final int THRESHOLD = 2;
private int start;
private int end;
public CountTask(int strat , int end){
this.start = strat;
this.end = end;
}
/**
* 必须重写的方法
* @return
*/
@Override
protected Integer compute() {
int sum = 0;
/**
* 如果任务足够小就计算任务
*/
boolean canCompute = (end - start) <= THRESHOLD ;
if( canCompute ){
for( int i = start ; i<= end ; i++){
sum += i;
}
}else{
/**
* 如果任务大于阀值,就分裂成两个子任务计算
*/
int middle = (start + end )/2;
CountTask leftTask = new CountTask(start , middle);
CountTask rightTask = new CountTask(middle +1 , end);
/**
* 执行子任务
*/
leftTask.fork();
rightTask.fork();
/**
* 等待子任务执行完,并得到其结果
*/
Integer leftResult = leftTask.join();
Integer rightResult = rightTask.join();
/**
* 合并子任务
*/
sum = leftResult + rightResult;
}
return sum;
}
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool();
/**
* 生成一个计算任务,负责计算 1+2+3+4
*/
CountTask task = new CountTask(1,4);
/**
* 执行一个任务
*/
ForkJoinTask<Integer> result = forkJoinPool.submit(task);
try {
System.out.println(result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}