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的不可见性与原子性。