Noções básicas de programação paralela com o Fork/Join Framework em Java

Uma visão geral

Programação paralela

A estrutura de bifurcação/junção

• ForkJoinTask: Esta é uma classe abstrata que define uma tarefa. Normalmente, uma tarefa é criada com a ajuda do fork() método definido nesta classe. Esta tarefa é quase semelhante a um thread normal criado com o Thread classe, mas é mais leve do que ela. O mecanismo que ele aplica é que permite o gerenciamento de um grande número de tarefas com a ajuda de um pequeno número de threads reais que se juntam ao ForkJoinPool . O fork() O método permite a execução assíncrona da tarefa de chamada. A junção() O método permite esperar até que a tarefa na qual é chamado seja finalmente finalizada. Existe um outro método, chamado invoke() , que combina o fork e participe operações em uma única chamada.
• ForkJoinPool: Esta classe fornece um pool comum para gerenciar a execução de ForkJoinTask tarefas. Ele basicamente fornece o ponto de entrada para envios de não ForkJoinTask clientes, bem como as operações de gerenciamento e monitoramento.
• Ação recursiva: Esta também é uma extensão abstrata do ForkJoinTask aula. Normalmente, estendemos essa classe para criar uma tarefa que não retorne um resultado ou tenha um void tipo de retorno. O computar() O método definido nesta classe é substituído para incluir o código computacional da tarefa.
• Tarefa Recursiva: Esta é outra extensão abstrata do ForkJoinTask aula. Estendemos essa classe para criar uma tarefa que retorne um resultado. E, semelhante ao ResursiveAction, também inclui um computação abstrata protegida() método. Este método é substituído para incluir a parte de computação da tarefa.

Estratégia da Estrutura Fork/Join

Um exemplo rápido

package org.mano.example;
import java.util.concurrent.RecursiveAction;
public class CustomRecursiveAction extends
      RecursiveAction {
   final int THRESHOLD = 2;
   double [] numbers;
   int indexStart, indexLast;
   CustomRecursiveAction(double [] n, int s, int l) {
      numbers = n;
      indexStart = s;
      indexLast = l;
   }
   @Override
   protected void compute() {
      if ((indexLast - indexStart) > THRESHOLD)
         for (int i = indexStart; i < indexLast; i++)
            numbers [i] = numbers [i] + Math.random();
         else
            invokeAll (new CustomRecursiveAction(numbers,
               indexStart, (indexStart - indexLast) / 2),
               new CustomRecursiveAction(numbers,
                  (indexStart - indexLast) / 2,
                     indexLast));
   }
}

package org.mano.example;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
public class Main {
   public static void main(String[] args) {
      final int SIZE = 10;
      ForkJoinPool pool = new ForkJoinPool();
      double na[] = new double [SIZE];
      System.out.println("initialized random values :");
      for (int i = 0; i < na.length; i++) {
         na[i] = (double) i + Math.random();
         System.out.format("%.4f ", na[i]);
      }
      System.out.println();
      CustomRecursiveAction task = new
         CustomRecursiveAction(na, 0, na.length);
      pool.invoke(task);
      System.out.println("Changed values :");
      for (inti = 0; i < 10; i++)
      System.out.format("%.4f ", na[i]);
      System.out.println();
   }
}

Conclusão