并发编程-07 ForkJoin分治

ForkJoin工作原理

ForkJoin框架时对线程池普通线程池的补充。我们通常在使用线程池时，会有哪些痛点？

• 无法对大任务进行拆分，单个任务只能交个单个线程执行
• 当阻塞队列中有积压时，工作线程从队列中获取任务会存在竞争

本篇文章就来研究Doug Lea是如何巧妙利用分治思想解决上述问题的。在开始看ForkJoin前，需要先对线程池线程数和死锁有些认识，否则啃完ForkJoin框架，也用不好它。

1、如何设计线程池的线程数？

通常我们会用如何方式，自定义线程池，核心线程、非核心线程、非核心线程的等待时间、阻塞队列等。那么线程数如何取值更合理的？

new ThreadPoolExecutor(nThreads, nThreads,
                              0L, TimeUnit.MILLISECONDS,
                              new LinkedBlockingQueue<Runnable>());

1.1 CPU密集型的任务

• 主要任务类型：加密、解密、压缩、计算等计算密集型任务
• 特点：计算压力大，CPU消耗大
• 最佳线程数：CPU核心数的1-2倍
• 原因：CPU密集型任务，主要耗时在计算上。线程需要充分利用CPU持续的完成大量计算任务，这时如果线程数量过多反而会因频繁的上下文切换，而造成性能下降。

1.2 IO密集型的计算

• 主要任务类型：数据库读写IO、网络IO、磁盘文件读写IO等网络通信任务
• 特点：CPU压力小，IO等待耗时长
• 最佳线程数：CPU核心数的N倍
• 原因：CPU计算压力小，更多的时间消耗在IO的阻塞上，频繁的切换上下文，能减少工作队列的等待耗时。

1.3 从业务实际角度考量

• 考虑业务的并发量、每秒可以处理的请求数、阻塞队列长度兜底保证浪涌情况下，不丢失请求
• 想要获取更准确线程数，需要经过压测来检验，结合实际情况，合理利用资源。

2、如何看待线程死锁、活锁

2.1 死锁问题

2.1.1 什么是死锁？

面试官：什么是死锁？（回答我，我就录取你！）

答：你录取我，我就告诉你什么是死锁！

死锁用生活中的道理表述 :双方继续执行下去的前提是，对方先满足自己的要求。(线程互相等待)

2.1.2 怎么解决死锁问题？

锁成立的必要条件：

• 互斥条件[AQS中的信号量state]

• 占有且等待[排它锁占有时，阻塞]

• 不可强行占有[当线程已获取到锁，在它释放前，其他线程无法cas占有]

• 循环等待条件(打破等待条件即可解决死锁)

2.1.3 死锁问题的场景

• 线程间相互等待导致的死锁。

  打破循环等待条件即可

  案例

• 线程饥饿，线程池瞬间满载阻塞，且没有中断策略。导致线程池无线程可用导致的死锁。ForkJoin如何拿来做阻塞类型任务，当线程饥饿时，极有可能导致该类问题。

  案例

2.1.4 活锁问题

线程A、B相互谦让，A发现B需要执行，将执行权交给B；线程B发现线程A需要执行，将执行权交给A，相互谦让，生成活锁。

案例

3、Fork/Join框架介绍

http://gee.cs.oswego.edu/dl/papers/fj.pdf Doug Lea 关于ForkJoin的论文

3.1 分治思想

思想比代码重要。充分利用多线程的优势，集中将庞大地、可拆分地任务进行fork(),分解到通过多个工作线程分别承担一部分任务，通过子线程的并行计算最终递归得到执行结果。

3.2 ForkJoinPool

3.2.1 构造方法

• parallelism 线程池的并行数[控制线程工厂中线程个数]

  控制工作线程的数量，未设置则使用默认的Runtime.getRuntime().availableProcessors()核数

• factory [负责工作线程创建的线程工厂]

  可是实现ForkJoinWorkerThreadFactory来自定义，默认DefaultForkJoinWorkerThreadFactory

• handler[异常处理]

  UncaughtExceptionHandler运行时异常的处理器

• asyncMode

  设置队列的工作模式：asyncMode ? FIFO_QUEUE : LIFO_QUEUE。相当于是否公平

public ForkJoinPool(int parallelism,
                    ForkJoinWorkerThreadFactory factory,
                    UncaughtExceptionHandler handler,
                    boolean asyncMode) {
    this(checkParallelism(parallelism),
         checkFactory(factory),
         handler,
         asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
         "ForkJoinPool-" + nextPoolId() + "-worker-");
    checkPermission();
}

3.2.2 核心任务提交方法

	返回值	方法
提交异步执行	void	execute(ForkJoinTask task) execute(Runnable task)
等待并获取结果	T	invoke(ForkJoinTask task)
提交执行获取Future结果	ForkJoinTask	submit(ForkJoinTask task) submit(Callable task) submit(Runnable task) submit(Runnable task, T result)

3.3 ForkJoinTask

ForkJoinTask是ForkJoinPool的核心之一，它是任务的实际载体，定义了任务执行时的具体逻辑和拆分逻辑。ForkJoinTask继承了Future接口，所以也可以将其看作是轻量级的Future。

3.3.1 ForkJoinTask核心方法

• fork() [查分任务提交到线程池]

  fork()方法用于向当前任务所运行的线程池中提交任务。如果当前线程是ForkJoinWorkerThread类型，将会放入该线程的工作队列，否则放入common线程池的工作队列中。

• join() [阻塞等待任务结果]

  join()方法用于获取任务的执行结果。调用join()时，将阻塞当前线程直到对应的子任务完成运行并返回结果

3.3.2 常用实现类

• RecursiveAction

  用于递归执行但不需要返回结果的任务

• RecursiveTask

  用于递归执行需要返回结果的任务。

• CountedCompleter

  在任务完成执行后会触发执行一个自定义的钩子函数

3.4 ForkJoinWorkerThread

由ForkJoinWorkerThreadFactory工厂创建的工作线程，每个线程与ForkJoinPool.WorkQueue队列深度绑定

普通线程池的预热

//核心线程的预热
ExecutorService executors = Executors.newFixedThreadPool(10);
((ThreadPoolExecutor)executors).prestartAllCoreThreads();

4、Fork/Join原理及使用场景

4.1 核心使用场景（递归计算返回结果）

使用场景：大量CPU计算场景。

案例：

public class ForkJoinTest {
    final static ForkJoinPool.ForkJoinWorkerThreadFactory factory = new ForkJoinPool.ForkJoinWorkerThreadFactory() {
        @Override
        public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
            final ForkJoinWorkerThread worker = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
            worker.setName("My-ForkJoin-thread-"+ worker.getPoolIndex());
            return worker;
        }
    };
    static ExecutorService executorService = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
        int arr[] = Utils.buildRandomIntArray(100000000);

        //为避免cpu缓存，先计算forkJoin分治算法
        testForkJoinSub(8,arr);
        //单线程耗时
        testForkJoinSub(arr);
        //并行流算法
        testParallelSum(arr);
    }

    /**
     * forkJoin算法
     *
     * @param parallelism
     * @param arr
     * @throws Exception
     */
    public static void testForkJoinSub(int parallelism,int arr[]) throws Exception {
        //Runtime.getRuntime().availableProcessors()  forkJoin默认并行数
        ForkJoinPool forkJoinPool = new ForkJoinPool(parallelism,factory,null,false);
        Instant now = Instant.now();
        RecursiveTask task = new CalcTask(arr,0,arr.length);

        //提交任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);

        Long aLong = submit.get();

        System.out.println("forkJoin sum="+aLong);
        System.out.println("forkJoin 耗时："+ Duration.between(now,Instant.now()).toMillis());
    }

    /**
     * 单线程计算结果
     * @param arr
     */
    public static void testForkJoinSub(int arr[]){
        Long sum = 0L;
        Instant now = Instant.now();
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("单线程 sum="+sum);
        System.out.println("单线程 耗时："+ Duration.between(now,Instant.now()).toMillis());
    }

    /**
     * stream流
     * @param arr
     */
    public static void testParallelSum(int arr[]){
        Instant now = Instant.now();
        Long sum = IntStream.of(arr).asLongStream().sum();
        System.out.println("stream流 sum="+sum);
        System.out.println("stream流 耗时："+ Duration.between(now,Instant.now()).toMillis());
    }
}

单线程、forkJoin、并行流计算的结果及耗时对比：

执行的结果
#print result
forkJoin sum=49951294336
forkJoin 耗时：48
单线程 sum=49951294336
单线程 耗时：493
stream流 sum=49951294336
stream流 耗时：72

Process finished with exit code 0

public class CalcTask extends RecursiveTask<Long> {
    // 任务拆分最小阈值
    static final int SEQUENTIAL_THRESHOLD = 10000000;

    int low;
    int high;
    int[] array;

    CalcTask(int[] arr, int lo, int hi) {
        array = arr;
        low = lo;
        high = hi;
    }

    @Override
    protected Long compute() {

        //当任务拆分到小于等于阀值时开始求和
        if (high - low <= SEQUENTIAL_THRESHOLD) {

            long sum = 0;
            for (int i = low; i < high; ++i) {
                sum += array[i];
            }
            return sum;
        } else {  // 任务过大继续拆分
            int mid = low + (high - low) / 2;
            CalcTask left = new CalcTask(array, low, mid);
            CalcTask right = new CalcTask(array, mid, high);
            // 提交任务
            left.fork();
            right.fork();
            //获取任务的执行结果,将阻塞当前线程直到对应的子任务完成运行并返回结果
            long rightAns = right.join();
            long leftAns = left.join();
            return leftAns + rightAns;
        }
    }
}

4.2 任务窃取

每个workQueue为了方便窃取任务，都是双端队列。

4.3 内外部提交任务流程图

5、思考

5.1 并流行的坑

ForkJoinTask在执行fork方法时可见，外部提交的任务由ForkJoinPool.common.externalPush(this)来执行

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

因此，如果forkjoin出现阻塞任务时，极有可能出现在开头中描述的因饥饿或阻塞的死锁。