Java并发的四种风味：Thread、Executor、ForkJoin和Actor 
ForkJoin工具类与实现demo 
1.工具类

package thread.demo_027;

import java.util.concurrent.RecursiveTask;


public class ForkJoinWork extends RecursiveTask<Long>{ private Long start;//开始值 private Long end;//介绍值 public static final Long critical =100000L;//临界值 public ForkJoinWork(Long start, Long end) { this.start=start; this.end=end; } @Override protected Long compute() { //判断是否拆分 Long lenth=end-start; if(lenth<=critical){ //如果拆分完毕就相加 Long sum=0L; for (Long i = start; i <=end; i++) { sum+=i; } return sum; }else{ //没有拆分完毕就开始拆分 Long middle=(end+start)/2;//计算2个值得中间值 ForkJoinWork right=new ForkJoinWork(start,middle); right.fork();//拆分，并压入线程队列 ForkJoinWork left=new ForkJoinWork(middle+1, end); left.fork(); //拆分 并加入线程队列 //合并 return right.join()+left.join(); } } }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49

2.工具类实现

package thread.demo_027; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.Future; import java.util.concurrent.RecursiveTask; /** * Fork/Join框架demo * */ public class ForkJoinDemo { private static int THRESLOD=10;//任务阈值 /** * 求1到100万之间的和，因为需要返回结果，所以需要继承recursiverTask */ static class MC extends RecursiveTask<Long>{ Long sum = Long.valueOf(0); private int begin,end; public MC(int begin, int end){ this.begin=begin; this.end=end; } //表示这个任务完成后，返回的一个值 @Override protected Long compute() { //如果任务量小于阈值，就直接计算 if ((end-begin)<=THRESLOD){ for (int i = begin; i <end ; i++) { sum +=i; } }else{//如果大于1000， 就把他拆分成两个子任务进行fork int mid= (end+begin)/2; MC left=new MC(begin,mid);//一部分小线程 left.fork();//开启这小部分线程 MC right= new MC(mid,end); right.fork(); Long li= left.join();//让left任务完整完成 Long lr= right.join();//让right任务完整完成 sum=li+lr; } return sum; } } public static void main(String[] args) throws Exception{ ForkJoinPool forkJoinPool =new ForkJoinPool();//创建他的线程池 Future<Long> ft=forkJoinPool.submit(new MC(0,10));//在线程池中进行计算 System.out.println("计算的结果是："+ft.get()); forkJoinPool.shutdown();//关闭线程池 } }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72

3.原理、ForkJoin框架实现： 
就是将并发的线程进行拆分、然后进行合并、但是有一个难题、比如一个复杂逻辑的 
怎么将一个线程任务、拆分多个任务、保证数据完整性与一致性。就相当于synchronized的不可见性与原子性。