JAVA并行框架：Fork/Join

落日映苍穹つ 2022-05-16 10:23 173阅读 0赞

转载自 [https://www.cnblogs.com/dongguacai/p/6021859.html][https_www.cnblogs.com_dongguacai_p_6021859.html]

# [JAVA并行框架：Fork/Join][https_www.cnblogs.com_dongguacai_p_6021859.html] #

## 一、背景 ##

虽然目前处理器核心数已经发展到很大数目，但是按任务并发处理并不能完全充分的利用处理器资源，因为一般的应用程序没有那么多的并发处理任务。基于这种现状，考虑把一个任务拆分成多个单元，每个单元分别得到执行，最后合并每个单元的结果。

Fork/Join框架是JAVA7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。

![fork/join][fork_join]

## 二、工作窃取算法 ##

指的是某个线程从其他队列里窃取任务来执行。使用的场景是一个大任务拆分成多个小任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列中，并且每个队列都有单独的线程来执行队列里的任务，线程和队列一一对应。但是会出现这样一种情况：A线程处理完了自己队列的任务，B线程的队列里还有很多任务要处理。A是一个很热情的线程，想过去帮忙，但是如果两个线程访问同一个队列，会产生竞争，所以A想了一个办法，从双端队列的尾部拿任务执行。而B线程永远是从双端队列的头部拿任务执行（任务是一个个独立的小任务），这样感觉A线程像是小偷在窃取B线程的东西一样。

![work-stealing][]

**工作窃取算法的优点：**

**         **利用了线程进行并行计算，减少了线程间的竞争。

**工作窃取算法的缺点：**

1、如果双端队列中只有一个任务时，线程间会存在竞争。

2、窃取算法消耗了更多的系统资源，如会创建多个线程和多个双端队列。

## 三、框架设计 ##

Fork/Join中两个重要的类：

**1、ForkJoinTask**：使用该框架，需要创建一个ForkJoin任务，它提供在任务中执行fork和join操作的机制。一般情况下，我们并不需要直接继承ForkJoinTask类，只需要继承它的子类，它的子类有两个：

a、RecursiveAction:用于没有返回结果的任务。

b、RecursiveTask:用于有返回结果的任务。

**2、ForkJoinPool**：任务ForkJoinTask需要通过ForkJoinPool来执行。

![复制代码][copycode.gif]

1 package test;
     2 
     3 import java.util.concurrent.ExecutionException;
     4 import java.util.concurrent.ForkJoinPool;
     5 import java.util.concurrent.Future;
     6 import java.util.concurrent.RecursiveTask;
     7 
     8 
     9 public class CountTask extends RecursiveTask<Integer>
    10 {
    11     private static final long serialVersionUID = 1L;
    12     //阈值
    13     private static final int THRESHOLD = 2;
    14     private int start;
    15     private int end;
    16     
    17     public CountTask(int start, int end)
    18     {
    19         this.start = start;
    20         this.end = end;
    21     }
    22 
    23     @Override
    24     protected Integer 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 = new  CountTask(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         return sum;
    54     }
    55     
    56     public static void main(String[] args)
    57     {
    58         ForkJoinPool forkJoinPool = new ForkJoinPool();
    59         CountTask task = new CountTask(1,6);
    60         //执行一个任务
    61         Future<Integer> 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 }

![复制代码][copycode.gif]

这个程序是将1+2+3+4+5+6拆分成1+2；3+4；5+6三个部分进行子程序进行计算后合并。

## 四、源码解读 ##

1、leftTask.fork();

![复制代码][copycode.gif]

1 public final ForkJoinTask<V> fork() {
    2         Thread t;
    3         if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
    4             ((ForkJoinWorkerThread)t).workQueue.push(this);
    5         else
    6             ForkJoinPool.common.externalPush(this);
    7         return this;
    8     }

![复制代码][copycode.gif]

fork方法内部会先判断当前线程是否是ForkJoinWorkerThread的实例，如果满足条件，则将task任务push到当前线程所维护的双端队列中。

![复制代码][copycode.gif]

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         }

![复制代码][copycode.gif]

在push方法中，会调用ForkJoinPool的signalWork方法唤醒或创建一个工作线程来异步执行该task任务。

2、

public final V join() {
            int s;
            if ((s = doJoin() & DONE_MASK) != NORMAL)
                reportException(s);
            return getRawResult();
        }

通过doJoin方法返回的任务状态来判断，如果不是NORMAL，则抛异常：

private void reportException(int s) {
            if (s == CANCELLED)
                throw new CancellationException();
            if (s == EXCEPTIONAL)
                rethrow(getThrowableException());
        }

来看下doJoin方法：

![复制代码][copycode.gif]

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

![复制代码][copycode.gif]

先查看任务状态，如果已经完成，则直接返回任务状态；如果没有完成，则从任务队列中取出任务并执行。

[https_www.cnblogs.com_dongguacai_p_6021859.html]: https://www.cnblogs.com/dongguacai/p/6021859.html
[fork_join]: http://img2.tuicool.com/IjQBz2.png%21web
[work-stealing]: http://img2.tuicool.com/q6bUzu.png%21web
[copycode.gif]: /images/20220516/4a79d2b9b7c84b639c1c9696bc92729e.png