一个大任务拆分成多个小任务,为了减少线程间的竞争,把这些子任务分别放到不同的队列中,并且每个队列都有单独的线程来执行队列里的任务,线程和队列一一对应。
但是会出现这样一种情况:A线程处理完了自己队列的任务,B线程的队列里还有很多任务要处理。
A是一个很热情的线程,想过去帮忙,但是如果两个线程访问同一个队列,会产生竞争,所以A想了一个办法,从双端队列的尾部拿任务执行。而B线程永远是从双端队列的头部拿任务执行。
注意:线程池中的每个线程都有自己的工作队列(PS,这一点和ThreadPoolExecutor不同,ThreadPoolExecutor是所有线程公用一个工作队列,所有线程都从这个工作队列中取任务),当自己队列中的任务都完成以后,会从其它线程的工作队列中偷一个任务执行,这样可以充分利用资源。
工作窃取算法的优点:
利用了线程进行并行计算,减少了线程间的竞争。
工作窃取算法的缺点:
1、如果双端队列中只有一个任务时,线程间会存在竞争。
2、窃取算法消耗了更多的系统资源,如会创建多个线程和多个双端队列。
3.主要类
- ForkJoinTask:
使用该框架,需要创建一个ForkJoin任务,它提供在任务中执行fork和join操作的机制。一般情况下,我们并不需要直接继承ForkJoinTask类,只需要继承它的子类,它的子类有两个:
- RecursiveAction:用于没有返回结果的任务。
- RecursiveTask:用于有返回结果的任务。
- ForkJoinPool:
任务ForkJoinTask需要通过ForkJoinPool来执行。
- ForkJoinWorkerThread:
ForkJoinPool线程池中的一个执行任务的线程。
Future 用来接受多线程池的结果
fork:起到将任务继续递归的作用
join:起到计算结果的作用
package pool;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
/*
1+2+3+...+100
*/
public class SumTask2 extends RecursiveTask<Long> {
int start;
int end;
int step=1000;
public SumTask2(int start, int end) {
this.start = start;
this.end = end;
}
public int getStart() {
return start;
}
public void setStart(int start) {
this.start = start;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
@Override
protected Long compute() {
//定义一个结果变量sum
long sum=0;
//计算结果
if (end - start <= step) {
for (int i = start; i <= end; i++) {
sum += i;
}
}else{//分解任务
int mid = (start + end) / 2;
SumTask2 leftTask = new SumTask2(start,mid);
SumTask2 rightTask = new SumTask2(mid+1, end);
//继续分解
leftTask.fork();
rightTask.fork();
//结果求和
long leftSum = leftTask.join();
long rightSum = rightTask.join();
sum = leftSum + rightSum;
}
//返回结果
return sum;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//使用循环求和
//计算机有四个核,只有一个核参与任务
int n=1000000000;
long sum=0;
long startTime = System.currentTimeMillis();
for (int i = 0; i <= n; i++) {
sum = sum + i;
}
long endTime = System.currentTimeMillis();
System.out.println("for loop:" + sum + ",time=" + (endTime - startTime));
//使用fork join求和
//创建一个forkjoin线程池
long startTime1 = System.currentTimeMillis();
ForkJoinPool pool = new ForkJoinPool();
//给出一个任务
RecursiveTask task = new SumTask2(1,n);
//将任务交给线程池(线程池会分解任务并合并结果)
Future<Long> future = pool.submit(task);
//获取结果
long result = future.get();
long endTime1 = System.currentTimeMillis();
System.out.println("forkjoin:"+result+ ",time=" + (endTime1 - startTime1));
//关闭forkjoin线程池
pool.shutdown();
}
}