ForkJoinPool框架示例

package com.expgiga.JUC;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
*
*/
public class TestForkJoinPool {
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();

ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 100000000000L);

Long sum = pool.invoke(task);

System.out.println(sum);

//jdk7
Instant start = Instant.now();
long summ = 0L;
for (long i = 0L; i <= 10000000000L; i++) {
sum += i;
}
System.out.println(summ);
Instant end = Instant.now();
System.out.println("消耗的时间：" + Duration.between(start, end).toMillis());

//jdk8
Instant startt = Instant.now();
Long summm = LongStream.rangeClosed(0L, 10000000000000L)
.parallel()
.reduce(0L, Long::sum);
System.out.println(summm);
Instant endd = Instant.now();
System.out.println("消耗的时间：" + Duration.between(startt, endd).toMillis());
}
}

class ForkJoinSumCalculate extends RecursiveTask<Long>{

/**
*
*/

private long start;
private long end;

private static final long THURSHOLD = 10000L;//临界值

public ForkJoinSumCalculate(long start, long end) {
this.start = start;
this.end = end;
}

@Override
protected Long compute() {

long length = end - start;

if (length <= THURSHOLD) {
long sum = 0L;

for (int i = 0; i <= end; i++) {
sum += i;
}
return sum;
} else {
long middle = (start + end) / 2;
ForkJoinSumCalculate left = new ForkJoinSumCalculate(start, middle);
left.fork(); //进行拆分，同时压入线程队列

ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle + 1, end);
right.fork();

return left.join() + right.join();
}

}
}