背景:ForkJoinPool的优势在于,可以充分利用多cpu,多核cpu的优势,把一个任务拆分成多个“小任务”,把多个“小任务”放到多个处理器核心上并行执行;当多个“小任务”执行完成之后,再将这些执行结果合并起来即可。这种思想值得学习。
介绍
Java7 提供了ForkJoinPool来支持将一个任务拆分成多个“小任务”并行计算,再把多个“小任务”的结果合并成总的计算结果。
ForkJoinPool是ExecutorService的实现类,因此是一种特殊的线程池。
使用方法:创建了ForkJoinPool实例之后,就可以调用ForkJoinPool的submit(ForkJoinTask<T> task) 或invoke(ForkJoinTask<T> task)方法来执行指定任务了。
其中ForkJoinTask代表一个可以并行、合并的任务。ForkJoinTask是一个抽象类,它还有两个抽象子类:RecusiveAction和RecusiveTask。其中RecusiveTask代表有返回值的任务,而RecusiveAction代表没有返回值的任务。
下面的UML类图显示了ForkJoinPool、ForkJoinTask之间的关系:
案列一:通过多线程分多个小任务进行打印数据 无返回值的
package forkJoinPool;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;
/**
* @author liuchaojun
* @date 2018-9-10 下午02:57:29
*
* RecursiveAction 无返回值的
*
*/
public class PrintTask extends RecursiveAction {
private static final long serialVersionUID = 1L;
private static final int INDEX = 50;
private int start;
private int end;
/**
*
*/
public PrintTask(int start, int end) {
// TODO Auto-generated constructor stub
this.start = start;
this.end = end;
}
/*
* (non-Javadoc)
*
* @see java.util.concurrent.RecursiveAction#compute()
*/
@Override
protected void compute() {
if (end - start < INDEX) {
for (int i = start; i < end; i++) {
System.out.println(Thread.currentThread().getName() + "----"
+ i);
}
} else {
int middle = (end + start) / 2;
PrintTask taskLeft = new PrintTask(start, middle);
PrintTask taskRight = new PrintTask(middle, end);
//taskLeft.invoke();执行给定的任务,在完成后返回其结果。
//并行执行两个“小任务”
/* taskLeft.fork();
taskRight.fork();*/
invokeAll(taskLeft, taskRight);//执行给定的任务
}
}
public static void main(String[] args) throws InterruptedException {
PrintTask task = new PrintTask(0, 300);
ForkJoinPool pool = new ForkJoinPool();
pool.submit(task);
pool.awaitTermination(2, TimeUnit.SECONDS);//阻塞2秒
pool.shutdown();
}
}
运行结果
本机电脑cpu4核,通过上面观察线程名称,可以看出4个cpu都在进行
案列二:通过多线程分多个小任务进行数据累加 返回结果集
package com.pinyougou.test.multithreading;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;
public class PrintTask2 {
public static void main(String[] args) throws Exception {
int[] arr = new int[200];
Random r = new Random();
int tempSum = 0;// 普通总数
for (int i = 0; i < arr.length; i++) {
tempSum += (arr[i] = r.nextInt(10));
}
System.out.println("普通总数结果为:" + tempSum);
ForkJoinPool pool = new ForkJoinPool();
MyTask task = new MyTask(0, arr.length, arr);
Future<Integer> sum = pool.submit(task);
System.out.println("多线程的执行结果:" + sum.get());// get 如果需要,等待计算完成,然后检索其结果。
pool.awaitTermination(2, TimeUnit.SECONDS);
pool.shutdown(); // 关闭线程池
}
}
class MyTask extends RecursiveTask<Integer> {
private static final long serialVersionUID = 1L;
private static final int INDEX = 50;// 每个小任务执行50个
private int start;
private int end;
private int arr[];
/**
* @param start
* @param end
* @param arr
*/
public MyTask(int start, int end, int[] arr) {
this.start = start;
this.end = end;
this.arr = arr;
}
/*
* (non-Javadoc)
*
* @see java.util.concurrent.RecursiveTask#compute()
*/
@Override
protected Integer compute() {
int sum = 0;
if (end - start < INDEX) {
for (int i = start; i < end; i++) {
sum += arr[i];
}
return sum;
} else {
int middle = (end + start) / 2;
MyTask taskLeft2 = new MyTask(start, middle, arr);
MyTask taskRight2 = new MyTask(middle, end, arr);
//invokeAll(taskLeft2, taskRight2);
taskLeft2.fork();
taskRight2.fork();
int leftValue = taskLeft2.join();// 当计算完成时返回计算结果。
int rightValue = taskRight2.join();
return leftValue + rightValue;
}
}
}
运行结果:
提供一些API 的方法,可以参考下
总结
1,invokeAll(task)方法,主动执行其它的ForkJoinTask,并等待Task完成。(同步的)
2,fork方法,让一个task执行(异步的)
3,join方法,让一个task执行(同步的,它和fork不同点是同步或者异步的区别)
4,可以使用join来取得ForkJoinTask的返回值。由于RecursiveTask类实现了Future接口,所以也可以使用get()取得返回值。
get()和join()有两个主要的区别:
join()方法不能被中断。如果你中断调用join()方法的线程,这个方法将抛出InterruptedException异常。
如果任务抛出任何未受检异常,get()方法将返回一个ExecutionException异常,而join()方法将返回一个RuntimeException异常。
5,ForkJoinTask在不显示使用ForkJoinPool.execute/invoke/submit()方法进行执行的情况下,也可以使用自己的fork/invoke方法进行执行。
使用fork/invoke方法执行时,其实原理也是在ForkJoinPool里执行,只不过使用的是一个“在ForkJoinPool内部生成的静态的”ForkJoinPool。
6,ForkJoinTask有两个子类,RecursiveAction和RecursiveTask。他们之间的区别是,RecursiveAction没有返回值,RecursiveTask有返回值。
7,看看ForkjoinTask的Complete方法的使用场景
这个方法好要是用来使一个任务结束。这个方法被用在结束异步任务上,或者为那些能不正常结束的任务,提供一个选择。
8,Task的completeExceptionally方法是怎么回事。
这个方法被用来,在异步的Task中产生一个exception,或者强制结束那些“不会结束”的任务
这个方法是在Task想要“自己结束自己”时,可以被使用。而cancel方法,被设计成被其它TASK调用。
当你在一个任务中抛出一个未检查异常时,它也影响到它的父任务(把它提交到ForkJoinPool类的任务)和父任务的父任务,以此类推。
9,可以使用ForkJoinPool.execute(异步,不返回结果)、invoke(同步,返回结果)、submit(异步,返回结果)方法,来执行ForkJoinTask。
10,ForkJoinPool有一个方法commonPool(),这个方法返回一个ForkJoinPool内部声明的静态ForkJoinPool实例。 在jdk1.8里面才有。文档上说,这个方法适用于大多数的应用。这个静态实例的初始线程数,为“CPU核数-1 ”(Runtime.getRuntime().availableProcessors() - 1)。
ForkJoinTask自己启动时,使用的就是这个静态实例。