Fork/Join
Fork/Join框架是Java 7提供的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。Fork/Join框架要完成两件事情:
1.任务分割:首先Fork/Join框架需要把大的任务分割成足够小的子任务,如果子任务比较大的话还要对子任务进行继续分割
2.执行任务并合并结果:分割的子任务分别放到双端队列里,然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里,启动一个线程从队列里取数据,然后合并这些数据。
在Java的Fork/Join框架中,使用两个类完成上述操作
1.ForkJoinTask:我们要使用Fork/Join框架,首先需要创建一个ForkJoin任务。该类提供了在任务中执行fork和join的机制。通常情况下我们不需要直接集成ForkJoinTask类,只需要继承它的子类,Fork/Join框架提供了两个子类:
a.RecursiveAction:用于没有返回结果的任务
b.RecursiveTask:用于有返回结果的任务
2.ForkJoinPool:ForkJoinTask需要通过ForkJoinPool来执行
任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。当一个工作线程的队列里暂时没有任务时,它会随机从其他工作线程的队列的尾部获取一个任务(工作窃取算法)。
摩尔定律
由英特尔(Intel)创始人之一戈登·摩尔(Gordon Moore)提出来的
集成电路上可容纳的元器件的数目,约每隔18-24个月便会增加一倍,性能也将提升一倍。
CPU 主频在2003年时就开始停止增长
摩尔定律仍然有效晶体管集成度仍然每18-24个月翻倍但是,是给更多的核(core),而不是更快
Concurrency/Parallelism
–Java 1 支持threads, locks, condition queues
–Java 5 引入了 thread pools, blocking queues, concurrent collections
–Java 7 加入了fork-join库
–Java 8 加入了 parallel streams
Concurrency vs Parallelism
目标都是最大化CPU的使用率
并发可认为是一种程序的逻辑结构的设计模式
可以用并发的设计方式去设计模型,然后运行在一个单核系统上
可以将这种模型不加修改地运行在多核系统上,实现真正的并行
并行是程序执行的一种属性
– 真正的同时执行(或发生)
Java 1.5中引入了Executor框架
实现计算逻辑与执行逻辑分离
提供了基于ThreadPool的Executor的实现
分治法
基本思想:把一个规模大的问题划分为规模较小的子问题,然后分而治之,最后合并子问题的解得到原问题的解。
步骤:
分割原问题:
求解子问题:
合并子问题的解为原问题的解。
在分治法中,子问题一般是相互独立的,因此,经常通过递归调用算法来求解子问题。
分治法典型应用
(1)二分搜索
(2)大整数乘法
(3)Strassen矩阵乘法
(4)棋盘覆盖
(5)合并排序
(6)快速排序
(7)线性时间选择
(8)汉诺塔
Fork-Join并行处理框架
Java 1.7 引入了一种新的并发框架—— Fork/Join Framework
主要用于实现“分而治之”的算法,特别是分治之后递归调用的函数。
提供了的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。
与ThreadPool共存,并不是要替换ThreadPool。
ForkJoinPool 框架主要类
ForkJoinPool 实现ForkJoin的线程池 - ThreadPool
ForkJoinWorkerThread 实现ForkJoin的线程
ForkJoinTask 一个描述ForkJoin的抽象类 Runnable/Callable
RecursiveAction 无返回结果的ForkJoinTask实现Runnable
RecursiveTask<V> 有返回结果的ForkJoinTask实现Callable
CountedCompleter<T> 在任务完成执行后会触发执行一个自定义的钩子函数
ForkJoinPool 实现了Executor Service 接口
ExecutorService 是Java Executor框架的基础类
其他ExecutorService的实现执行Runnable或Callables任务
ForkJoinPool执行ForkJoinTasks任务
ForkJoinPool 实现了Executor Service 接口
ExecutorService 是Java Executor框架的基础类
其他ExecutorService的实现执行Runnable或Callables任务
ForkJoinPool执行ForkJoinTasks任务
Executors. newWorkStealPool创建ForkJoinPool
ForkJoinPool任务提交方法
返回值 | 方法签名 |
---|---|
void | execute(ForkJoinTask<?> task)/execute(Runnable task) |
T | invoke(ForkJoinTask task) |
List<Future> | invokeAll(Collection<? extends Callable> tasks) |
ForkJoinTask | submit(ForkJoinTask task)/submit(Callable task)/submit(Runnable task)/submit(Runnable task, T result) |
ForkJoinTask封装了数据及其相应的计算
支持细粒度的数据并行
ForkJoinTask比线程要轻量
ForkJoinPool中少量工作线程能够运行大量的ForkJoinTask
ForkJoinTask主要包括两个方法分别实现任务的分拆与合并:
1、fork()类似于Thread.start(),但是它并不立即执行任务,而是将任务放入工作队列中
2、跟Thread.join()不同,ForkJoinTask的join()方法并不简单的阻塞线程
利用工作线程运行其他任务
当一个工作线程中调用join(),它将处理其他任务,直到注意到目标子任务已经完成
ForkJoinTask有3个子类:
RecursiveAction
无返回值的任务
RecursiveTask
有返回值的任务
CountedCompleter
完成任务后将触发其他任务
ForkJoinPool中的所有的工作线程均有一个自己的工作队列WorkQueue
双端队列(Deque)
从队头取任务
线程私有,不共享
ForkJoinTask中fork的子任务,将放入运行该任务的工作线程的队头
工作线程以LIFO的顺序来处理它队列中的任务
WorkQueue双端队列最小化任务“窃取”的竞争
push()/pop()仅在其所有者工作线程中调用
这些操作都是通过CAS来实现的,是Wait-free的
poll() 则由其他工作线程来调用“窃取”任务
可能不是wait-free
Fork/Join框架的实现原理
ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成,ForkJoinTask数组负责将存放程序提交给ForkJoinPool,而ForkJoinWorkerThread负责执行这些任务。
ForkJoinTask的Fork方法的实现原理:当我们调用ForkJoinTask的fork方法时,程序会把任务放在ForkJoinWorkerThread的pushTask的workQueue中,异步地执行这个任务,然后立即返回结果,代码如下:
public final ForkJoinTask<V> fork() {
Thread t;
if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
((ForkJoinWorkerThread)t).workQueue.push(this);
else
ForkJoinPool.common.externalPush(this);
return this;
}
pushTask方法把当前任务存放在ForkJoinTask数组队列里。然后再调用ForkJoinPool的signalWork()方法唤醒或创建一个工作线程来执行任务。代码如下:
final void push(ForkJoinTask<?> task) {
ForkJoinTask<?>[] a; ForkJoinPool p;
int b = base, s = top, n;
if ((a = array) != null) { // ignore if queue removed
int m = a.length - 1; // fenced write for task visibility
U.putOrderedObject(a, ((m & s) << ASHIFT) + ABASE, task);
U.putOrderedInt(this, QTOP, s + 1);
if ((n = s - b) <= 1) {
if ((p = pool) != null)
p.signalWork(p.workQueues, this);
}
else if (n >= m)
growArray();
}
}
ForkJoinTask的join方法实现原理
Join方法的主要作用是阻塞当前线程并等待获取结果。让我们一起看看ForkJoinTask的join方法的实现,代码如下:
public final V join() {
int s;
if ((s = doJoin() & DONE_MASK) != NORMAL)
reportException(s);
return getRawResult();
}
它首先调用doJoin方法,通过doJoin()方法得到当前任务的状态来判断返回什么结果,任务状态有4种:已完成(NORMAL)、被取消(CANCELLED)、信号(SIGNAL)和出现异常(EXCEPTIONAL)。
如果任务状态是已完成,则直接返回任务结果。
如果任务状态是被取消,则直接抛出CancellationException
如果任务状态是抛出异常,则直接抛出对应的异常
让我们分析一下doJoin方法的实现
private int doJoin() {
int s; 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();
}
final int doExec() {
int s; boolean completed;
if ((s = status) >= 0) {
try {
completed = exec();
} catch (Throwable rex) {
return setExceptionalCompletion(rex);
}
if (completed)
s = setCompletion(NORMAL);
}
return s;
}
在doJoin()方法里,首先通过查看任务的状态,看任务是否已经执行完成,如果执行完成,则直接返回任务状态;如果没有执行完,则从任务数组里取出任务并执行。如果任务顺利执行完成,则设置任务状态为NORMAL,如果出现异常,则记录异常,并将任务状态设置为EXCEPTIONAL。
Fork/Join框架的异常处理
ForkJoinTask在执行的时候可能会抛出异常,但是我们没办法在主线程里直接捕获异常,所以ForkJoinTask提供了isCompletedAbnormally()方法来检查任务是否已经抛出异常或已经被取消了,并且可以通过ForkJoinTask的getException方法获取异常。使用如下代码:
if(task.isCompletedAbnormally()){
System.out.println(task.getException());
}
使用例子:
使用Fork/Join框架首先要考虑到的是如何分割任务,如果希望每个子任务最多执行两个数的相加,那么我们设置分割的阈值是2,由于是4个数字相加,所以Fork/Join框架会把这个任务fork成两个子任务,子任务一负责计算1+2,子任务二负责计算3+4,然后再join两个子任务的结果。因为是有结果的任务,所以必须继承RecursiveTask,实现代码如下:
public class CountTask extends RecursiveTask<Integer> {
private static final int THREAD_HOLD = 2;
private int start;
private int end;
public CountTask(int start,int end){
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
int sum = 0;
//如果任务足够小就计算
boolean canCompute = (end - start) <= THREAD_HOLD;
if(canCompute){
for(int i=start;i<=end;i++){
sum += i;
}
}else{
int middle = (start + end) / 2;
CountTask left = new CountTask(start,middle);
CountTask right = new CountTask(middle+1,end);
//执行子任务
left.fork();
right.fork();
//获取子任务结果
int lResult = left.join();
int rResult = right.join();
sum = lResult + rResult;
}
return sum;
}
public static void main(String[] args){
ForkJoinPool pool = new ForkJoinPool();
CountTask task = new CountTask(1,10);
Future<Integer> result = pool.submit(task);
try {
System.out.println(result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
自己总结完整java知识地址访问:https://www.yuque.com/yangxinlei/lodfss