Associar Tarefa a uma Thread

Programação Java
#1

Olá Pessoal,

Tenho uma dúvida sobre Threads com Java.
Ao criar um Thread, gostaria de associar esta thread a uma tarefa.
Exemplo.
Tenho um vetor, de Task’s. E tenho uma Thread.

ArrayList<Task> vetor = new ArrayList<Task>();
//Assumindo que o vetor ja está preenchido.
Thread t1 = new Thread();

Gostaria de que a Thread, pegasse a tarefa da primeira posição do vetor, e a executasse.

Abraços
Bruno

#2 

Thread task1 = new Thread() { public void run() { /*código da task a executar*/ };
task1.start();

Era algo como isto que tu querias?

Basicamente o que tens de fazer é colocar a tarefa a executar dentro do método run(), depois quando utilizares o método start() o código em run será executado. Espero ter ajudado.

#3

Então, mas neste caso, eu não estou criando novamente uma Thread chamada Task?

Eu gostaria de pegar um Task (que é do Tipo Runnable) de dentro do vetor, e fazer com que um Thread a execute, ou seja, chame o objeto run deste objeto.
Exemplo:

vetor[0].run();   -> Porém eu gostaria de que isto fosse executado por uma thread.

O que ocorre é o seguinte, eu terei um vetor de Threads e um vetor de Objetos do Tipo Runnable.
Preciso implementar isto, de tal maneira, que as threads vão executando os objetos Runnable no vetor, até que este fique vazio.
Porém não posso utilizar as bibliotecas javas de ThreadPool.
Por isso que eu gostaria de “escolher” qual thread irá executar o objeto no vetor e como mandar uma thread fazer isto.

Não sei se me expressei bem, porém aqui está o que necessito fazer.

Ja tenho algumas coisas prontas, porém para continuar não estou conseguindo associar uma Thread qualquer a aos objetos do tipo Runnable.
abraços
Bruno

#4

vc passa o seu Runnable no construtor da Thread. Depois é só dar o start() na Thread que o método run() do objeto Runnable será executado.

#5

Quando uma thread termina um Runnable, ela não pode reiniciar a execução, com um novo Runnable. Seria necessário criar outra thread, que é justamente o que o seu pool quer evitar.

Portanto, você deve criar um outro Runnable, que gerencie isso para você. Esse runnable não terminaria. Ele receberia uma task, a executaria, e então aguardaria uma nova Task.

Seria algo mais ou menos assim:

[code]
public PoolRunner implements Runnable {
public Runnable aRunnable = null;

public void setRunnable(Runnable runnable) {
if (aRunnable != null)
throw new IllegalArgumentException(“There’s already a task running on this thread!”);
if (runnable == null)
throw new IllegalArgumentException(“Cannot submit a null task!”);

  this.aRunnable = runnable;

  //Vamos avisar o nosso método run() de que temos trabalho a fazer.
  notify();

}

private synchronized void waitTask() {
//Precisamos do while para evitar o spurious wakeup
while (!hasTask())
wait();
}

public void hasTask() {
return aRunnable != null;
}

public void run() {
try {
//Se formos interrompidos, abandonamos a thread.
//Assim vc usa o interrupt para “matar” o Pool.
while (!Thread.interrupted()) {
//Esperamos uma Task para o processamento
waitTask();

        //Processamos essa task.
        aRunnable.run();

        //E limpamos a variável para na próxima iteração 
        //esperarmos novamente.
        aRunnable = null;
     }
  catch (InterruptedException e) {
  }

}
}[/code]

Cada thread do seu pool irá ter como Runnable instâncias desse cara. Note que essa instância controlará um outro Runnable, sua Task, que será submetida ao Pool.

Note que, apesar da sua task executar inteira, após o seu termino esse runnable voltará a chamar o wait() e manterá a thread dormindo até que outra task seja submetida a ele.

Você ainda pode adicionar a essa classe um mecanismo para notificar o Pool de threads ao qual ela pertence de que a task em execução terminou de executar.

#6