Java clase de ForkJoin detallada

En la antigüedad, los emperadores con el fin de lograr una cosa, luego, no con manos, sino para servir las siguientes tareas descomponen. Los siguientes ministros también perezosos, por lo que la tarea continúa para dar varias partes, continúan el próximo número, así que al final para completar las manos de la persona a cargo de una pequeña función. Estos resultados son entonces dirección de la capa superior de la capa de resumen. Finalmente regresó al emperador, que se cree divide y vencerás, y es nuestro tema de hoy ForkJoin.

I. Introducción

Desde el comienzo JDK1.7, Java proporciona el marco para ForkJoin y realizar tareas, se cree que una gran tarea en tareas más pequeñas, los resultados de los resultados de resumen final de cada tarea pequeña a gran tarea.

1, ForkJoinPool

Dado que la tarea se refina poco a poco, a continuación, hay una necesidad de poner en común dentro de estas tareas. El estanque es ForkJoinPool, que ExecutorService otra diferencia principal es la principal diferencia es que utiliza una "obra de robo," Entonces, ¿qué es "trabajar para robarlo"?

A grandes tareas se dividen en numerosas pequeñas tareas que se asignan a diferentes colas, colas algún trabajo seca rápido, un trabajo lento, por lo que se seque rápido, yo no veo la necesidad de realizar una tarea, es ir al lado de tomar el interior de cola de ejecución de la tarea.

2, ForkJoinTask

ForkJoinTask es ForkJoinPool interior de cada tarea, que tiene dos subcategorías principales:

RecursiveAction y RecursiveTask, a continuación, asignar tareas a realizar tareas de tenedor () método, el método por Únete a los resultados resumidos de la tarea.

Este uso del proceso, que tiene dos subclases, utilizar dos subclases pueden lograr nuestra asignación de tareas y cálculo.

(1) RecursiveAction un recursiva concluyentes ForkJoinTask (sin valor de retorno)

(2) el resultado de un RecursiveTask (valor de retorno) recursivo ForkJoinTask

ForkJoinPool por la matriz ForkJoinTask y ForkJoinWorkerThread de matrices, matriz ForkJoinTask responsable de almacenar programas presentados a la tarea ForkJoinPool, y es responsable de la implementación de esta matriz ForkJoinWorkThread estas tareas.

Aquí nos fijamos en cómo utilizar el marco ForkJoin.

En segundo lugar, el uso

1, RecursiveTask: volver siempre

(1) Paso 1: Crear la clase MyRecursiveTask RecursiveAction hereda:

public class MyRecursiveTask extends RecursiveTask<Integer> {

    private final static int threshold = 3;
    private final int start;
    private final int end;

    public MyRecursiveTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        //如果任务分到不能再细分，那就直接计算
        if (end - start <= threshold) {
            return IntStream.rangeClosed(start, end).sum();
        } else {
            int mid = (start + end) / 2;
            MyRecursiveTask leftTask = new MyRecursiveTask(start, mid);
            MyRecursiveTask rightTask = new MyRecursiveTask(mid, end);
            leftTask.fork();
            rightTask.fork();
            return leftTask.join() + rightTask.join();
        }
    }
}

(2) Paso 2: Crear ForkJoinTest clase de prueba:

public class ForkJoinTest {

    public static void main(String[] args) {
        try {
            final ForkJoinPool pool =new ForkJoinPool();
            ForkJoinTask<Integer> result= pool.submit(new MyRecursiveTask(0,100));
            System.out.println("result = [" + result.get() + "]");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

2, RecursiveAction: sin resultados de retorno

(1) Paso 1: Crear MyRecursiveAction heredó RecursiveAction;

public class MyRecursiveAction extends RecursiveAction {

    private final static int threshold = 3;
    public  static final AtomicInteger sum = new AtomicInteger(0);
    private final int start;
    private final int end;


    public MyRecursiveAction(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        //如果任务拆分到不能再细分，那就计算
        if (end - start <= threshold) {
            sum.addAndGet(IntStream.rangeClosed(start, end).sum());
        }else {
            int mid = (start+end)/2;
            MyRecursiveAction  leftTask = new MyRecursiveAction(start,mid);
            MyRecursiveAction rightTask = new MyRecursiveAction(mid,end);
            leftTask.fork();
            rightTask.fork();
        }
    }
}

(2) Paso 2: Crear ForkJoinTest clase de prueba:

public class ForkJoinTest {

    public static void main(String[] args) {
        try {
            final ForkJoinPool pool = new ForkJoinPool();
            pool.submit(new MyRecursiveAction(0, 100));
            pool.awaitTermination(3, TimeUnit.SECONDS);
            System.out.println("sum=" + MyRecursiveAction.sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}