fork/join框架

时间  2019-11-26
标签 fork join 框架 栏目 Apache 繁體版
原文   原文链接

 

1. Fork/Join是什么

 

　　Fork/Join框架是Java 7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每一个小任务结果后获得大任务结果的框架。Fork/Join框架要完成两件事情：html

 　　Oracle的官方给出的定义是：Fork/Join框架是一个实现了ExecutorService接口的多线程处理器。它能够把一个大的任务划分为若干个小的任务并发执行，充分利用可用的资源，进而提升应用的执行效率。java

　　　　1.任务分割：首先Fork/Join框架须要把大的任务分割成足够小的子任务，若是子任务比较大的话还要对子任务进行继续分割算法

　　　　2.执行任务并合并结果：分割的子任务分别放到双端队列里，而后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另一个队列里，启动一个线程从队列里取数据，而后合并这些数据。数组

　　Fork/Join实现了ExecutorService，因此它的任务也须要放在线程池中执行。它的不一样在于它使用了工做窃取算法，空闲的线程能够从满负荷的线程中窃取任务来帮忙执行。多线程

　　Fork/Join框架的核心是继承了AbstractExecutorService的ForkJoinPool类，它保证了工做窃取算法和ForkJoinTask的正常工做。并发

　　在Java的Fork/Join框架中，使用两个类完成上述操做框架

　　1.ForkJoinTask:咱们要使用Fork/Join框架，首先须要建立一个ForkJoin任务。该类提供了在任务中执行fork和join的机制。一般状况下咱们不须要直接集成ForkJoinTask类，只须要继承它的子类，Fork/Join框架提供了两个子类：异步

　　　　a.RecursiveAction：用于没有返回结果的任务ide

　　　　b.RecursiveTask:用于有返回结果的任务ui

　　2.ForkJoinPool:ForkJoinTask须要经过ForkJoinPool来执行

　　　　任务分割出的子任务会添加到当前工做线程所维护的双端队列中，进入队列的头部。当一个工做线程的队列里暂时没有任务时，它会随机从其余工做线程的队列的尾部获取一个任务(工做窃取算法)。

　　　　执行方法有同步的：invoke，异步的execute和submit

2. Fork/Join框架的实现原理

　　ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成，ForkJoinTask数组负责将存放程序提交给ForkJoinPool，而ForkJoinWorkerThread负责执行这些任务。

2.1 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();
            }
        }

2.2 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();
            }
        }

2.3 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。

2.4 Fork/Join框架的异常处理

　　ForkJoinTask在执行的时候可能会抛出异常，可是咱们没办法在主线程里直接捕获异常，因此ForkJoinTask提供了isCompletedAbnormally()方法来检查任务是否已经抛出异常或已经被取消了，而且能够经过ForkJoinTask的getException方法获取异常。使用以下代码：

if(task.isCompletedAbnormally())
{
    System.out.println(task.getException());
}

　　getException方法返回Throwable对象，若是任务被取消了则返回CancellationException。若是任务没有完成或者没有抛出异常则返回null。

public final Throwable getException() {
        int s = status & DONE_MASK;
        return ((s >= NORMAL)    ? null :
                (s == CANCELLED) ? new CancellationException() :
                getThrowableException());
    } 

3. Fork/Join的基本用法

3.1 任务类FrokJoinTask

上文已经提到，Fork/Join就是要讲一个大的任务分割成若干小的任务，因此第一步固然是要作任务的分割，大体方式以下：

if (这个任务足够小){ 
  执行要作的任务 

} else { 

  将任务分割成两小部分 

  执行两小部分并等待执行结果 

}

 

要实现FrokJoinTask咱们须要一个继承了RecursiveTask或RecursiveAction的基类，并根据自身业务状况将上面的代码放入基类的coupute方法中。RecursiveTask和RecursiveAction都继承了FrokJoinTask，它俩的区别就是RecursiveTask有返回值而RecursiveAction没有。下面是我作的一个选出字符串列表中还有"a"的元素的Demo：

@Override 
   protected List<String> compute() { 

       // 当end与start之间的差小于阈值时，开始进行实际筛选 

       if (end - this.start < threshold) { 

           List<String> temp = list.subList(this.start, end); 

　　　　　　 return temp.parallelStream().filter(s -> s.contains("a")).collect(Collectors.toList()); 

       } else { 

           // 若是当end与start之间的差大于阈值时 

           // 将大任务分解成两个小任务。 

　　　　　　 int middle = (this.start + end) / 2; 

           ForkJoinTest left = new ForkJoinTest(list, this.start, middle, threshold); 

           ForkJoinTest right = new ForkJoinTest(list, middle, end, threshold); 

           // 并行执行两个“小任务” 

　　　　　　left.fork(); 

　　　　　　right.fork(); 

           // 把两个“小任务”的结果合并起来 

           List<String> join = left.join(); 

　　　　　　join.addAll(right.join()); 

　　　　　　return join; 

       } 

   }

　　

 

3.2 执行类ForkJoinPool

作好了基类就能够开始调用了，调用时首先咱们须要Fork/Join线程池ForkJoinPool，而后向线程池中提交一个ForkJoinTask并获得结果。ForkJoinPool的submit方法的入参是一个ForkJoinTask，返回值也是一个ForkJoinTask，它提供一个get方法能够获取到执行结果。

代码以下：

　　　　 ForkJoinPool pool = new ForkJoinPool(); 
        // 提交可分解的ForkJoinTask任务 
        ForkJoinTask<List<String>> future = pool.submit(forkJoinService); 
        System.out.println(future.get()); 
        // 关闭线程池 
        pool.shutdown();

　　

就这样咱们就完成了一个简单的Fork/Join的开发。

提示：Java8中java.util.Arrays的parallelSort()方法和java.util.streams包中封装的方法也都用到了Fork/Join。

3.3 ForkJoinPool的维护方法

ForkJoinPool提供了一系列的维护方法，好比获取执行线程数量，完成数量，查看偷取任务数等。

4. 实例代码

 1. 定义抽象类(用于拓展，此例中没有实际做用，能够不定义此类)：

import java.util.concurrent.RecursiveTask; 
 
/** 
 * Description: ForkJoin接口 
 * Designer: jack 
 * Date: 2017/8/3 
 * Version: 1.0.0 
 */ 
public abstract class ForkJoinService<T> extends RecursiveTask<T>{ 
    @Override 
    protected abstract T compute(); 
}

　2. 任务类

import java.util.List; 
import java.util.stream.Collectors; 
 
/** 
 * Description: ForkJoin基类 
 * Designer: jack 
 * Date: 2017/8/3 
 * Version: 1.0.0 
 */ 
public class ForkJoinTest extends ForkJoinService<List<String>> { 
 
    private static ForkJoinTest forkJoinTest; 
    private int threshold;  //阈值 
    private List<String> list; //待拆分List 
 
    private ForkJoinTest(List<String> list, int threshold) { 
        this.list = list; 
        this.threshold = threshold; 
    } 
 
    @Override 
    protected List<String> compute() { 
        // 当end与start之间的差小于阈值时，开始进行实际筛选 
        if (list.size() < threshold) { 
            return list.parallelStream().filter(s -> s.contains("a")).collect(Collectors.toList()); 
        } else { 
            // 若是当end与start之间的差大于阈值时,将大任务分解成两个小任务。 
            int middle = list.size() / 2; 
            List<String> leftList = list.subList(0, middle); 
            List<String> rightList = list.subList(middle, list.size()); 
            ForkJoinTest left = new ForkJoinTest(leftList, threshold); 
            ForkJoinTest right = new ForkJoinTest(rightList, threshold); 
            // 并行执行两个“小任务” 
            left.fork(); 
            right.fork(); 
            // 把两个“小任务”的结果合并起来 
            List<String> join = left.join(); 
            join.addAll(right.join()); 
            return join; 
        } 
    } 
 
    /** 
     * 获取ForkJoinTest实例 
     * @param list  待处理List 
     * @param threshold 阈值 
     * @return ForkJoinTest实例 
     */ 
    public static ForkJoinService<List<String>> getInstance(List<String> list, int threshold) { 
        if (forkJoinTest == null) { 
            synchronized (ForkJoinTest.class) { 
                if (forkJoinTest == null) { 
                    forkJoinTest = new ForkJoinTest(list, threshold); 
                } 
            } 
        } 
        return forkJoinTest; 
    } 
}

　3. 执行类

import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.List; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ForkJoinPool; 
import java.util.concurrent.ForkJoinTask; 
 
/** 
 * Description: Fork/Join执行类 
 * Designer: jack 
 * Date: 2017/8/3 
 * Version: 1.0.0 
 */ 
public class Test { 
 
    public static void main(String args[]) throws ExecutionException, InterruptedException { 
 
        String[] strings = {"a", "ah", "b", "ba", "ab", "ac", "sd", "fd", "ar", "te", "se", "te", 
                "sdr", "gdf", "df", "fg", "gh", "oa", "ah", "qwe", "re", "ty", "ui"}; 
        List<String> stringList = new ArrayList<>(Arrays.asList(strings)); 
 
        ForkJoinPool pool = new ForkJoinPool(); 
        ForkJoinService<List<String>> forkJoinService = ForkJoinTest.getInstance(stringList, 20); 
        // 提交可分解的ForkJoinTask任务 
        ForkJoinTask<List<String>> future = pool.submit(forkJoinService); 
        System.out.println(future.get()); 
        // 关闭线程池 
        pool.shutdown(); 
 
    } 
 
}

　　

参考

http://developer.51cto.com/art/201708/547413.htm

https://www.cnblogs.com/senlinyang/p/7885964.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程