jdk中的ForkJoin

Forkjoin与普通线程池有很大的相似之处。包括用来执行ForkJoinTask的线程池ForkJoinPool，用来定义任务的ForkJoinTask（不过我们更多是用它的子类无返回值的任务RecursiveAction，有返回值的任务RecursiveTask）。通过继承ForkJoinTask(RecursiveAction,RecursiveTask)来定义线程任务。
相对于普通的线程池，ForkJoin最大的特点是可以简单的将任务分成一个个子任务执行，且能控制任务的执行顺序(普通线程池也可以做到，不过ForkJoin用起来比较简单)。对于ForkJoin很多地方都会提起由于他的工作窃取算法（方案一）导致其性能会比普通线程池好。
针对这个结论一定要注意其指的普通线程池并不是普通广泛意义上的线程池，更精确的说是一种类似ForkJoin处理方式的线程池设计方案（方案二），即把主任务分成一个个子任务，并将这些子任务放到一个个队列中，一个线程只执行其中一个队列中的任务。

此时若是子任务之间工作量不均衡，那么因为工作量较大的线程会耗时过多(此时其它工作完的线程被挂起)，这种情况系使用线程ForkJoin会比普通线程池快。但是，如果工作量是均衡的，或者说是并没有将子任务划分为一个个队列，每个任务属于某一个线程，而是将每个子任务都放到线程池的等待队里（方案三）。这两种情况下ForkJoin并不见得比普通线程池有很大性能优势，甚至会发生由于额外的维护工作量使得性能有极其细微的下降。

至于如何使用ForkJoin以及为何说方案一和方案三性能差距不大，还是通过代码更有说服力：

ForkJoinDemo：

package forkAndJoin;

import java.util.Arrays;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;

public class ForkJoinDemo {

    public static void main(String[] args) {
        
        final int count = 10000;
        int poolSize = 4;
        int oneResult = 0;
        int fjResult = 0;
        int fjMaxCount = count/poolSize + 1;
        int epResult = 0;
        final int sizeOfOneThread = count/poolSize;
        final ConcurrentLinkedQueue<Integer> cQueue = new ConcurrentLinkedQueue<Integer>();
        int[] arr = ForkJoinUtil.createIntArr(count);
        
        int[] oneArr = Arrays.copyOf(arr, arr.length);
        ForkJoinPool fjPool = new ForkJoinPool(poolSize);
        long t1 = System.currentTimeMillis();
        oneResult = ForkJoinUtil.process("one", 0, count, oneArr);
        long t2 = System.currentTimeMillis();
        
        int[] fjArr = Arrays.copyOf(arr, arr.length);
        ArrStatisticsTask task = new ArrStatisticsTask(0, count, fjArr,fjMaxCount);
        long t3 = System.currentTimeMillis();
        fjPool.submit(task);
        fjResult = task.join();
        long t4 = System.currentTimeMillis();
        
        ExecutorService espool = Executors.newFixedThreadPool(poolSize);
        final CountDownLatch cdl = new CountDownLatch(poolSize);
        final int[] epArr = Arrays.copyOf(arr, arr.length);
        long t5 = System.currentTimeMillis();
        for (int i = 0; i < poolSize; i++) {
            final int j = i;
            Runnable esrun = new Runnable() {
                
                @Override
                public void run() {
                    int resultTemp = ForkJoinUtil.process("ep", j*sizeOfOneThread, (j+1)*sizeOfOneThread, epArr);
                    cQueue.offer(resultTemp);
                    cdl.countDown();
                }
            };
            espool.execute(esrun);
        }

        try {
            cdl.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long t6 = System.currentTimeMillis();
        while (!cQueue.isEmpty()) {
            epResult += cQueue.poll();
        }
        System.out.println("one:" + (t2 - t1));
        System.out.println("result:" + oneResult);
        System.out.println("fjpool:" + (t4 - t3));
        System.out.println("fjresult:" + fjResult);
        System.out.println("epool:" + (t6 - t5));
        System.out.println("epresult:" + epResult);
    }
}

ArrStatisticsTask：

package forkAndJoin;

import java.util.concurrent.RecursiveTask;

public class ArrStatisticsTask extends RecursiveTask<Integer> {

    /**
     */
    private static final long serialVersionUID = 1L;

    private int maxcount;
    
    private int start;
    
    private int end;
    
    private int[] arr;
    

    public ArrStatisticsTask(int start, int end, int[] arr, int maxcount) {
        super();
        this.start = start;
        this.end = end;
        this.arr = arr;
        this.maxcount = maxcount; 
    }
    
    @Override
    protected Integer compute() {
        try {
            if (end - start <= maxcount) {
                return ForkJoinUtil.process("fj", start, end, arr);
            }
            
            int middle = (start + end) / 2;
            ArrStatisticsTask task1 = new ArrStatisticsTask(start, middle, arr, maxcount);
            ArrStatisticsTask task2 = new ArrStatisticsTask(middle, end, arr, maxcount);
            invokeAll(task1, task2);    // 这里要使用invokeAll方法，而不要使用 .fork()方法。invokeAll会将两个任务分一个给当前线程，而两个.fork方法会导致当前线程被挂起，再另启两个线程导致资源浪费
            return task1.join() + task2.join();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return 0;
    }

}

ForkJoinUtil：

package forkAndJoin;

import java.util.Random;

public class ForkJoinUtil {

    public static int process(String name, int s, int e, int[] arr) {
        int r = 0;
        for (int i = s; i < e; i++) {
            System.out.println(name + "-old-" + i + "-" + arr[i]);
            if (arr[i] < 5) {
                r++;
            }
            int newI = 0;
            for (int j = 0; j < i; j++) {
                int newIt = 0;
                for (int j2 = 0; j2 < j; j2++) {
                    newIt += j2; 
                }
                newI += newIt;
            }
            arr[i] = newI;
            System.out.println(name + "-new-" + i + "-" + arr[i]);
        }
        return r;
    }
    
    public static int[] createIntArr(int length) {
        Random r = new Random();
        int[] arr = new int[length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(10);
        }
        return arr;
    }
    
}

结果：

one:54330
result:5033
fjpool:31341
fjresult:5033
epool:31284
epresult:5033