Fork/Join框架
Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架,使得应用能充分利用线程进行并行计算，并减少了线程间的竞争。
所谓Fork就是把一个大任务切分为若干子任务并行的执行，Join则是合并这些子任务的执行结果，最后得到这个大任务的结果。
比如计算1+2+。。＋1000，可以分割成10个子任务，每个子任务分别对100个数进行求和，最终汇总这10个子任务的结果。
Fork/Join的运行流程
第一步分割任务。首先我们需要有一个fork类来把大任务分割成子任务，有可能子任务还是很大，所以还需要不停的分割，直到分割出的子任务足够小。分割的子任务分别放在一个双端队列里.
第二步执行任务并合并结果。然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个单独队列里，启动一个线程从队列里拿数据，然后合并这些数据。
实现
Fork/Join使用两个类来完成以上两件事情：
ForkJoinTask
我们要使用ForkJoin框架，必须首先创建一个ForkJoin任务。它提供在任务中执行fork()和join()操作的机制。
通常情况下我们不需要直接继承ForkJoinTask类，而只需要继承它的子类，Fork/Join框架提供了以下两个子类：
- RecursiveAction：用于没有返回结果的任务。
- RecursiveTask ：用于有返回结果的任务。
ForkJoinPool
ForkJoinTask需要通过ForkJoinPool来执行，它是一个特殊的ExecutorService.任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。
范例一：计算1到10000的数据的和
说明：本例只是用来介绍fork-join的使用，实际简单运算中使用单线程处理实际速度会更快，多线程更适合单个任务执行时间比较长时使用
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoin extends RecursiveTask<Integer>{
final int step=1000000000;//表示每个任务最多只计算100个数字的和，比如从1加到200就分层1+100和101+200两个任务
private int from;//从哪里开始计算
private int to;//到哪里结束计算
public ForkJoin(int from,int to){
this.from=from;
this.to=to;
}
@Override
protected Integer compute() {
if((to-from)<step){
//小于100个数，直接计算
return sum(from,to);
}
//拆分任务,一分为二
int middle=(from+to)/2;
ForkJoin task1=new ForkJoin(from,middle);
ForkJoin task2=new ForkJoin(middle+1,to);
//执行子任务(异步)
task1.fork();
task2.fork();
//等待子任务结果
int t1=task1.join();
int t2=task2.join();
return t1+t2;
}
private int sum(int from,int to){
// System.out.println("from:"+from+",to:"+to);
int sum=0;
for(int i=from;i<=to;i++){
sum+=i;
}
return sum;
}
public static void main(String[] arg) throws Exception {
long t1 = System.currentTimeMillis();
//fork/join需要ForkJoinPoll执行
ForkJoinPool pool=new ForkJoinPool();
System.out.println(pool.submit(new ForkJoin(1,1000000000)).get());
long t2 = System.currentTimeMillis();
System.out.println("t2-t1:"+(t2-t1)+"ms");
}
}
范例二：使用二分法查找所有大于0.5的数据个数
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoinCounter extends RecursiveTask<Integer>{
private static final long serialVersionUID = 1587552485829092262L;
public static final int THREAD_HOLD = 3;
private Double[] nums;
private int from;
private int to;
private Filter filter;
public ForkJoinCounter(Double[] nums, int from, int to, Filter filter) {
super();
this.nums = nums;
this.from = from;
this.to = to;
this.filter = filter;
}
@Override
protected Integer compute() {
// TODO Auto-generated method stub
int count = 0;
if (to - from < THREAD_HOLD) {
for (int i = from; i < to; ++i) {
if (filter.accept(nums[i]))
++count;
}
} else {
int mid = (from + to) / 2;
ForkJoinCounter leftCounter = new ForkJoinCounter(nums, from, mid, filter);
ForkJoinCounter rightCounter = new ForkJoinCounter(nums, mid, to, filter);
invokeAll(leftCounter, rightCounter);
count = leftCounter.join() + rightCounter.join();
}
return count;
}
public static void main(String[] arg) throws Exception {
final int SIZE = 10;
Double[] nums = new Double[SIZE];
for (int i = 0; i < SIZE; ++i) {
nums[i] = Math.random();
System.out.println(nums[i] + " ");
}
ForkJoinPool pool = new ForkJoinPool();
ForkJoinCounter counter = new ForkJoinCounter(nums, 0, nums.length, new Filter() {
@Override
public boolean accept(double t) {
// TODO Auto-generated method stub
if(t > 0.5) return true;
return false;
}
});
pool.invoke(counter);
System.out.println("N: " + counter.join());
}
}
interface Filter {
public boolean accept(double t);
}
范例三：根据订单id分成多个任务，每个任务最多不能超过10条数据，查询所有订单的详情信息
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoin1 extends RecursiveTask<List<OrderDetail>>{
final int THREAD_HOLD = 10;
private List<String> list;
private int from;
private int to;
public ForkJoin1(int from,int to,List<String> list) {
this.from = from;
this.to = to;
this.list = list;
}
@Override
protected List<OrderDetail> compute() {
if(list.size()<=10){
try{
return queryOrderDetail(list);
}catch(Exception e){}
}
int middle = (from + to)/2;
ForkJoin1 task1= null;
ForkJoin1 task2 = null;
if((from + to)%2==0){
task1 = new ForkJoin1(from, middle-1, list.subList(from, middle));
task2 = new ForkJoin1(from, middle, list.subList(middle, to+1));
}else{
task1 = new ForkJoin1(from, middle, list.subList(from, middle+1));
task2 = new ForkJoin1(from, middle, list.subList(middle+1, to+1));
}
//执行子任务(异步)
task1.fork();
task2.fork();
//等待子任务结果
List<OrderDetail> orderList1 = task1.join();
List<OrderDetail> orderList2 = task2.join();
List<OrderDetail> list = new ArrayList();
list.addAll(orderList1);
list.addAll(orderList2);
return list;
}
private List<OrderDetail> queryOrderDetail(List<String> list) throws Exception{
List<OrderDetail> orderList = new ArrayList();
for(int i=0;i<list.size();i++){
// Thread.sleep(1000L);
OrderDetail detail = new OrderDetail();
detail.setOrderId(list.get(i));
detail.setProductName("productName"+list.get(i));
orderList.add(detail);
}
return orderList;
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
long t1 = System.currentTimeMillis();
List<String> list = new ArrayList();
//模拟有100条订单id
for(int i=100000;i<100100;i++){
list.add(i+"");
}
//fork/join需要ForkJoinPoll执行
ForkJoinPool pool=new ForkJoinPool();
List<OrderDetail> orderList = pool.submit(new ForkJoin1(0,99,list)).get();
long t2 = System.currentTimeMillis();
System.out.println("t2-t1:"+(t2-t1)+"ms,size="+orderList.size());
}
}
class OrderDetail {
private String orderId;
private String productName;
public String getOrderId() {
return orderId;
}
public String getProductName() {
return productName;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public void setProductName(String productName) {
this.productName = productName;
}
}