Você está na página 1de 2

O framework Fork-Join uma melhoria da interface ExecutorService, foi

projetada para trabalhos que podem ser divididos em varias pequenas tarefas
recursivamente, tirando vantagens de mltiplos processadores, fazendo
paralelismo, voc divide uma tarefa em varias pequenas (fork) e depois as
junta novamente (join) quando esto completas. O objetivo usar todo o poder
de processamento disponvel para aumentar a performance das nossas
aplicaes.

A grande diferena desse framework com os outros que trabalham com
mltiplos processadores que ele usa um algoritmo work-stealing que pode ser
rodado por fora, podendo roubar tarefas de outras threads que ainda esto
ocupadas.

No JDK7 a funcionalidade Fork-join esta contida no objeto Forkjointask, so os
mtodos Fork() e Join().

- fork(): um mtodo que permite um novo ForkJoinTask ser lanado de um j
existente.
- join(): um mtodo que permite um ForkJointask esperar pela a concluso de
outro.

O objeto ForkjoinTask pode ser: RecursiveAction, que representa execues
que no tem retorno e RecursiveTask que tem um retorno.

Exemplo de cdigo usando fork join:
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

class Globals {
static ForkJoinPool fjPool = new ForkJoinPool();
}

class Sum extends RecursiveTask<Long> {
static final int SEQUENTIAL_THRESHOLD = 5000;

int low;
int high;
int[] array;

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

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;
Sum left = new Sum(array, low, mid);
Sum right = new Sum(array, mid, high);
left.fork();
long rightAns = right.compute();
long leftAns = left.join();
return leftAns + rightAns;
}
}

static long sumArray(int[] array) {
return Globals.fjPool.invoke(new Sum(array,0,array.length));
}
}

Explicao do cdigo acima:
O Objeto SUM que nos d um array e o seu range.
Temos o mtodo COMPUTE que responsvel pela soma dos elementos que
esto dentro do intervalo.
Caso o intervalo seja menor que SEQUENTIAL_THRESHOLD ele entra no
lao para incrementar o objeto SUM. Caso seja maior ele cria dois objetos
SUM. A partir da ele usa o fork para calcular a metade esquerda em paralelo
com o clculo da metade da direita. Para termos o clculo do lado direito
chamado objeto RIGHT.COMPUTE() e para resposta do lado esquerdo, chama
LEFT.JOIN().
Primeiro voc cria outro objeto ento chama o mtodo fork que comea a
computao em paralelismo (o mtodo fork o retorna mesmo rapidamente).

Quando voc precisa de uma resposta voc chama o mtodo join no objeto
que voc chamou o fork. O mtodo join vai pegar a sua resposta do Compute()
que foi descoberto pelo fork, se ele no estiver preparado o join vai bloquear
(ex.: sem retorno) at estar pronto, ento o ponto chamar o fork o mais cedo
possvel and chamar o join o mais tarde possvel fazendo um trabalho conjunto.

Esse exemplo soma todos os elementos de um array usando paralelismo para
potencializar processos diferentes de 5000-elemento segmentado em paralelo.

Você também pode gostar