Threads algumas duvidas

Programação Java
#1

ae pessoal tenho algumas duvidas em relação a threads to lendo o cap 9 da kathy e fiquei com as seguintes duvidas:

qual a diferença de instanciar um objeto thread da class Thread e implementar da interface Runnable?
qual a essencia de usar threads?
na pg 383 em portugues do livro da kathy diz que o maximo de prioridade de um thread é 110 nao seria 10?
Thread.MAX.PRIORITY(110). ta assim lá…
quem puder me ajudar com essas duvidas agradeço…
valeu galera!!

#2

é simples, uma classe pode extender a outra apenas uma vez, enquanto a mesma pode implementar várias interfaces, ou seja, se sua classe já estiver estendida a uma outra classe qualquer, então você pode implementar a classe Runnable.

espero poder ter ajudado.

#3

só pra complementar…

public class Thread extends Object implements Runnable

a própria classe Thread implementa Runnable, então quando extends ela, você vai implementar Runnable de qualquer forma =]

#4

Você pode criar Thread de duas formas:

-> Extendendo da classe Thread, onde a vantagem principal é que vc herda todos os métodos públicos da classe Thread;

-> Implementando a Interface Runnable, onde a vantagem é que vc pode herdar de alguma outra classe.

A essência de Threads seria criar processos concorrentes para que permitam que o usuário não fique parado esperando que um processo acabe, para que ele continue suas tarefas na aplicação. Imagine vc em uma aplicação onde ao iniciar um download de suas atualizações, vc não consiga clicar no botão cancelar caso esteja demorando muito!!

A prioridade máxima de uma Thread é 10, a mínima é 1 e a normal é 5.

Espero ter ajudado!!
Flw aew e t+!!

#5

Voce ainda pode usar as constantes pre-definidas, pra deixar seu codigo mais legivel :wink:

#6

po galera valeu entao a essencia do uso de threads seria… fazer varias coisas ao mesmo tempo? e se eu usar extends a Thread nao posso extender a outra class… entao é melhor usar a interface runnable diretamente que posso extends uma class qualquer e implementar runnable…
e a questao do da prioridade de threads foi um erro na tradução… pois ta o valor 110.

#7

Hoje em dia se recomenda sempre implementar Runnable, não extender Thread.

Isso porque a classe Thread representa um mecanismo de execução, enquanto a interface mostra o que pode ser executado.

Por exemplo, vamos supor que você tenha uma classe que pode ser iniciada em outra thread. Você pode executa-la assim:

Thread t = new Thread(new SuaClasse());
t.start();

Ok. Mas com o tempo você percebe que sua aplicação cria e destroi muitas threads desse tipo (gasta-se muito tempo para criar e destruir uma Thread) gerando um problema de performance acusado por seu profiler. A solução seria usar um Pool de Threads. Como se faz isso?

//Isso aqui vira uma propriedade
ExecutorService threadExecutor = Executors.newCachedThreadPool();

//E no código mesmo você faz
threadExecutor.execute(new SuaClasse());

Vê? Se SuaClasse fosse uma instancia de Thread, você ainda poderia fazer isso, mas estaria desperdiçando código à toa. Conceitualmente, você também estaria dizendo que “sua classe é um executor de Threads”, o que provavelmente estaria errado. Com a interface Runnable, você diz “Minha classe pode ser executada numa Thread”.

Fique atento que se você fosse implementar o Pool à mão, sua classe de Thread teria uma série de controles que estariam relacionados a Thread em si, não à sua classe. Para você seria melhor criar uma filha de Thread com os controles e, novamente, manter sua classe simplesmente implementando Runnable.

Note que, a partir do Java 5, Runnable não é a única interface que um executor pode disparar em uma nova Thread. Existem também a interface Callable, que é um Runnable que retorna valor.

Você pode fazer:

[code]
public class SomaMultithread implements Callable
{
private int a, b;
public SomaMultithread(int a, int b) {
this.a = a;
this.b = b;
}

 public Integer call() {
     return a+b;

}[/code]

E executar a sua classe em outra Thread fazendo:

Future<Integer> resultado = threadExecutor.submit(new SomaMultithread(10,20)); System.out.println("O resultado da soma foi:" + resultado.get());

#8

você deve ter trocado na hora de digitar… “se recomenda sempre implementar Runnable, não extends Thread”

Eu não conhecia a interface Callable!

Gostei da explicação!

até!

#9

Tá certo… inverti mesmo! Foi na empolgação! hehehehe

Dê uma olhada também na interface Future, que guarda o resultado do callable. A vantagem dele é que o método get() do future fica fica esperando a computação do Callable acabar.

Não muito útil se você tem um Callable só, mas é bastante interessante se você disparar vários Callables e depois quiser totalizar o resultado deles de alguma forma.

Para facilitar as coisas, ainda existe a classe FutureTask, que te dá o poder de um Runnable e de um Callable ao mesmo tempo. Vale a pena pesquisar! :wink:

#10