Estou com um problema no uso do FutureTask. O meu programa é de um Produtor e Consumidor. Ele funcionava usando o método run(), implementado de Runnable. Mas trocando para call, o programa gera um erro no debug que eu não entendo...mesmo estando dentro de um try/catch, nada mais é lançado no console.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class SharedBufferMain
{
public static void main(String[] args)
{
ExecutorService executorService = Executors.newCachedThreadPool();
SharedBuffer sharedBuffer = new SharedBuffer();
FutureTask<Integer> futureTask1 = new FutureTask<Integer>(new Produtor(sharedBuffer));
FutureTask<Integer> futureTask2 = new FutureTask<Integer>(new Consumidor(sharedBuffer));
executorService.execute(futureTask1);
executorService.execute(futureTask2);
executorService.shutdown();
}
}
import java.util.Random;
import java.util.concurrent.Callable;
public class Produtor implements Callable<Integer>
{
SharedBuffer sharedBuffer;
private static Random r = new Random();
public Produtor(SharedBuffer sharedBuffer)
{
this.sharedBuffer = sharedBuffer;
}
public Integer call() throws Exception
{
System.out.printf("%-40s%s\t\t%s\n%-40s%s\n\n", "Posição", "Vetor", "Valor",
"---------", "------\t\t-------");
for(int posicao = 0; posicao < 100; posicao++ )
{
sharedBuffer.setValor(posicao, r.nextInt(100));
}
return 1;
}
}
import java.util.concurrent.Callable;
public class Consumidor implements Callable<Integer>
{
SharedBuffer sharedBuffer;
public Consumidor(SharedBuffer sharedbuffer)
{
this.sharedBuffer = sharedBuffer;
}
public Integer call() throws Exception
{
for(int posicao = 0; posicao < 100; posicao ++)
{
sharedBuffer.getValor(posicao);
}
return null;
}
}
public interface ProdutorConsumidor
{
public void setValor(int posicao, int valor);
public int getValor(int posicao);
}
public class SharedBuffer implements ProdutorConsumidor
{
public static final int tamanhoBuffer = 10;
public static int buffer [] = new int[tamanhoBuffer];
public boolean turn;
public int valor;
public int getValor(int posicao)
{
synchronized(buffer)
{
while(!turn)
{
try
{
buffer.wait();
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
valor = buffer[posicao%tamanhoBuffer];
turn = false;
buffer.notify();
return valor;
}
}
public void setValor(int posicao, int valor)
{
synchronized(buffer)
{
while(turn)
{
try
{
buffer.wait();
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
buffer[posicao%tamanhoBuffer] = valor;
turn = true;
buffer.notify();
//System.out.printf("\n%s %d%d\n%s\n", posicao, posicao%tamanhoBuffer, valor);
System.out.println(posicao+" "+
posicao%tamanhoBuffer+" "+valor);
}
}
}
int[](Object).wait() line: 485 [local variables unavailable]
SharedBuffer.setValor(int, int) line: 16
Produtor.call() line: 21
Produtor.call() line: 1
FutureTask$Sync.innerRun() line: not available [local variables unavailable]
FutureTask<V>.run() line: not available [local variables unavailable]
ThreadPoolExecutor$Worker.runTask(Runnable) line: not available
ThreadPoolExecutor$Worker.run() line: not available [local variables unavailable]
Thread.run() line: not available [local variables unavailable]
Quando uma thread entra na classe Produtor, ele é enviado à classe SharedBuffer através do for. Ao chegar, ele entra no método set(i), depois de obter o objeto de monitor. Bem, se conseguiu, verifica se pode continuar, em turn. Se não puder, é dado um wait na thread que chamou o método. Esse wait libera o objeto de monitor e coloca a thread em espera.
Um segunda thread entra em Consumidor. Pelo for, ela entra em get() da classe SharedBuffer. Verifica se pode obter o objeto de monitor. Depois, verifica se é a sua vez (turn). Depois, se for, ela faz o que tiver de fazer e dá um notify, colocando a outra thread em espera no estado de bloqueado. Agora, se a thread em Consumidor tentar novamente entrar em get() para consumir, ela adormecerá.
A primeira thread, agora bloqueada, pode tentar novamente obter o objeto de monitor. Irá conseguir e tenta produzir...and so on...
Bem, essa é a minha lógica. Se alguém vir algo errado no código, me dê um toque por favor!