一、背景
虽然目前处理器核心数已经发展到很大数目,但是按任务并发处理并不能完全充分的利用处理器资源,因为一般的应用程序没有那么多的并发处理任务。基于这种现状,考虑把一个任务拆分成多个单元,每个单元分别得到执行,最后合并每个单元的结果。
Fork/Join框架是JAVA7提供的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。
二、工作窃取算法
指的是某个线程从其他队列里窃取任务来执行。使用的场景是一个大任务拆分成多个小任务,为了减少线程间的竞争,把这些子任务分别放到不同的队列中,并且每个队列都有单独的线程来执行队列里的任务,线程和队列一一对应。但是会出现这样一种情况:A线程处理完了自己队列的任务,B线程的队列里还有很多任务要处理。A是一个很热情的线程,想过去帮忙,但是如果两个线程访问同一个队列,会产生竞争,所以A想了一个办法,从双端队列的尾部拿任务执行。而B线程永远是从双端队列的头部拿任务执行(任务是一个个独立的小任务),这样感觉A线程像是小偷在窃取B线程的东西一样。
工作窃取算法的优点:
利用了线程进行并行计算,减少了线程间的竞争。
工作窃取算法的缺点:
1、如果双端队列中只有一个任务时,线程间会存在竞争。
2、窃取算法消耗了更多的系统资源,如会创建多个线程和多个双端队列。
三、框架设计
Fork/Join中两个重要的类:
1、ForkJoinTask:使用该框架,需要创建一个ForkJoin任务,它提供在任务中执行fork和join操作的机制。一般情况下,我们并不需要直接继承ForkJoinTask类,只需要继承它的子类,它的子类有两个:
a、RecursiveAction:用于没有返回结果的任务。
b、RecursiveTask:用于有返回结果的任务。
2、ForkJoinPool:任务ForkJoinTask需要通过ForkJoinPool来执行。
1 packagetest;2
3 importjava.util.concurrent.ExecutionException;4 importjava.util.concurrent.ForkJoinPool;5 importjava.util.concurrent.Future;6 importjava.util.concurrent.RecursiveTask;7
8
9 public class CountTask extends RecursiveTask
10 {11 private static final long serialVersionUID = 1L;12 //阈值
13 private static final int THRESHOLD = 2;14 private intstart;15 private intend;16
17 public CountTask(int start, intend)18 {19 this.start =start;20 this.end =end;21 }22
23 @Override24 protectedInteger compute()25 {26 int sum = 0;27 //判断任务是否足够小
28 boolean canCompute = (end - start) <=THRESHOLD;29 if(canCompute)30 {31 //如果小于阈值,就进行运算
32 for(int i=start; i<=end; i++)33 {34 sum +=i;35 }36 }37 else
38 {39 //如果大于阈值,就再进行任务拆分
40 int middle = (start + end)/2;41 CountTask leftTask = newCountTask(start,middle);42 CountTask rightTask = new CountTask(middle+1,end);43 //执行子任务
44 leftTask.fork();45 rightTask.fork();46 //等待子任务执行完,并得到执行结果
47 int leftResult =leftTask.join();48 int rightResult =rightTask.join();49 //合并子任务
50 sum = leftResult +rightResult;51
52 }53 returnsum;54 }55
56 public static voidmain(String[] args)57 {58 ForkJoinPool forkJoinPool = newForkJoinPool();59 CountTask task = new CountTask(1,6);60 //执行一个任务
61 Future result =forkJoinPool.submit(task);62 try
63 {64 System.out.println(result.get());65 }66 catch(InterruptedException e)67 {68 e.printStackTrace();69 }70 catch(ExecutionException e)71 {72 e.printStackTrace();73 }74
75 }76
77 }
这个程序是将1+2+3+4+5+6拆分成1+2;3+4;5+6三个部分进行子程序进行计算后合并。
四、源码解读
1、leftTask.fork();
1 public final ForkJoinTaskfork() {2 Thread t;3 if ((t = Thread.currentThread()) instanceofForkJoinWorkerThread)4 ((ForkJoinWorkerThread)t).workQueue.push(this);5 else
6 ForkJoinPool.common.externalPush(this);7 return this;8 }
fork方法内部会先判断当前线程是否是ForkJoinWorkerThread的实例,如果满足条件,则将task任务push到当前线程所维护的双端队列中。
1 final void push(ForkJoinTask>task) {2 ForkJoinTask>[] a; ForkJoinPool p;3 int b = base, s =top, n;4 if ((a = array) != null) { //ignore if queue removed
5 int m = a.length - 1; //fenced write for task visibility
6 U.putOrderedObject(a, ((m & s) << ASHIFT) +ABASE, task);7 U.putOrderedInt(this, QTOP, s + 1);8 if ((n = s - b) <= 1) {9 if ((p = pool) != null)10 p.signalWork(p.workQueues, this);11 }12 else if (n >=m)13 growArray();14 }15 }
在push方法中,会调用ForkJoinPool的signalWork方法唤醒或创建一个工作线程来异步执行该task任务。
2、
public finalV join() {ints;if ((s = doJoin() & DONE_MASK) !=NORMAL)
reportException(s);returngetRawResult();
}
通过doJoin方法返回的任务状态来判断,如果不是NORMAL,则抛异常:
private void reportException(ints) {if (s ==CANCELLED)throw newCancellationException();if (s ==EXCEPTIONAL)
rethrow(getThrowableException());
}
来看下doJoin方法:
private intdoJoin() {ints; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;return (s = status) < 0 ?s :
((t= Thread.currentThread()) instanceof ForkJoinWorkerThread) ?(w= (wt =(ForkJoinWorkerThread)t).workQueue).
tryUnpush(this) && (s = doExec()) < 0 ?s :
wt.pool.awaitJoin(w,this, 0L) :
externalAwaitDone();
}
先查看任务状态,如果已经完成,则直接返回任务状态;如果没有完成,则从任务队列中取出任务并执行。