1、 使用示例
import java.lang.reflect.Method;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ThreadLocalRandom;
public class ForkJoinDemo {
public static void main(String[] args) throws Exception{
//使用ForkJoinPool来执行任务
ForkJoinPool forkJoinPool = new ForkJoinPool();
//生成一个计算任务，负责计算1+2+3+4
CountTaskTmp task = new CountTaskTmp(1, 100000000);
long r = forkJoinPool.invoke(task);
System.out.println(r);
}
}
@SuppressWarnings("serial")
// RecursiveTask是ForkJoinTask的子类
class CountTaskTmp extends RecursiveTask<Long> {
private static final long THRESHOLD = 10000000;
private long start;
private long end;
public CountTaskTmp(long start, long end) {
this.start = start;
this.end = end;
}
//实现compute 方法来实现任务切分和计算
@Override
protected Long compute() {
long sum = 0;
boolean canCompute = (end - start) <= THRESHOLD;
if (canCompute) {
for (long i = start; i <= end; i++)
sum += i;
} else {
//如果任务大于阀值，就分裂成两个子任务计算
long mid = (start + end) / 2;
CountTaskTmp leftTask = new CountTaskTmp(start, mid);
CountTaskTmp rightTask = new CountTaskTmp(mid + 1, end);
System.out.println("fork开始");
//执行子任务
leftTask.fork();
rightTask.fork();
System.out.println("fork完毕");
//等待子任务执行完，并得到结果
System.out.println("join开始");
long leftResult = leftTask.join();
long rightResult = rightTask.join();
System.out.println("join完毕");
sum = leftResult + rightResult;
}
return sum;
}
}
2、简写说明：
下面：
ForkJoinWorkerThread简写为Thread
ForkJoinWorkerPool简写为pool
ForkJoinWorkerTask简写为task
workQueue简写为queue
3、任务窃取大致实现原理
在上面示例中，我们通过THRESHOLD字段指定每个任务计算1千万个数据，如果超过一千万，则使用二分法把任务切分为leftTask和rightTask。如果leftTask和rightTask还是超过一千万数据，还会继续切分，当任务足够小，就开始真正执行计算逻辑。整个过程有点类似递归。下面使用伪码简单看下工作过程：
class ForkJoinTask{
fork(){
forJoinPool.push(this) //把任务提交到pool执行
}
T join(){
synchronized(this){
wait();//等待任务执行完毕，任务执行完毕会调用notify
}
return getRawResult();//返回当前task的结果
}
}
class WorkQueue{
ForkJoinThread owner;
ForkJoinTask array[];//存放task的数组
int top=base=0;
push(task){
//如果数组长度不够了，则创建一个长度更大的数组
growArray()
//把task放到array
array[top++]=task
}
//当这个workQueue的所属线程执行任务时，调用pop获取task
pop(){
return array[top--];
}
//当其他线程要窃取这个队列的任务时，使用poll窃取任务。通过base和top两个变量，array成了双向队列。
// pop是后进先出，而poll则是先进先出。当队列的owner执行自身队列中的task时，通过pop获得任务，
//而其他队列要窃取该队列的task时，则用该队列的poll进行任务窃取
poll(){
return array[base++];
}
growArray(){
//当array大小不够时，创建更大的数组，并把旧数组的元素拷贝到新数组
}
}
class ForkJoinPool{
WorkQueue workQueues[];//workQueue保存task
push(task){
//从workQueues选择一个工作队列，将task放入其中
selectOneWorkQueueFromWorkQueues().add(task)
signalWork(); //通知worker执行任务
}
signalWork(){
if(线程池每有足够的活动线程){
//使用Unsafe的unpark唤醒休眠的线程或调用createWorker创建新线程，并启动该线程
}
}
createWorker(){
new ForkJoinThread(this).start();
}
// ForkJoinThread构造函数中调用，借此把新new出来的ForkJoinThread注册到ForkJoinPool
registerWorker(ForkJoinThread thread){
WorkerQueue workQueue=new WorkerQueue();
// 简单起见，这里暂时理解randomIndex是一个小于workQueues长度的随机数
workQueues[randomIndex]=workQueue;
workQueue.owner=thread
return workerQueue;
}
}
class ForkJoinThread{//Thread的子类
ForkJoinPool pool;
WorkQueue workQueue;
ForkJoinThread(ForkJoinPool pool){
this.pool=pool;
this. workQueue=pool.registerWorker(this);
}
run(){//调用Thread的start方法时，run方法就会被调用
while(!terminate){
//不断执行task，每当任务执行完毕，执行notifyall通知所有等待的worker
//当自身task执行完就从pool中随机选择workQueue，并窃取该workQueue的任务来执行
//如果窃取不到任务，且当前worker由于调用了join，在等待其他线程的任务完成，则当前线程休眠
//如果窃取不到任务，且无需等待其他线程任务的执行，则线程终止
}
}
————————————————
版权声明：本文为CSDN博主「花公子丶」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yu766588220/article/details/106870548