Threads em Java

Threads em Java - Introdução revisão em 11/11/2008
Conceitos:
Diferença entre processo e thread:
Um processo é um programa em execução que possui o seu próprio espaço de endereçamento.
Um sistema operacional multitarefa é capaz de controlar a execução de mais de um processo
ao mesmo tempo, de forma concorrente, fazendo a CPU alternar a execução das instruções de
cada processo.
Uma thread é um fluxo seqüencial de controle, ou linha de execução, dentro de um processo

ou programa. Um processo pode assim ter diversas threads executando concorrentemente,
mas todas partilhando o mesmo espaço de endereçamento. Como não há necessidade de
trocar de contexto, as threads representam uma forma mais leve de processamento
concorrente.
Porque usar threads em aplicações:

Threads têm várias utilidades, especialmente quando o uso de um recurso do programa pode
demandar muito tempo, e travar outras tarefas que estão aguardando, ou quando se precisa
ficar verificando a ocorrência de algum evento para efetuar alguma ação. Nesse último caso,
uma thread pode ficar dedicada apenas para verificar periodicamente a ocorrência do evento.
A aplicação mais usual é a interação com as interfaces gráficas (menus, botões) quando se
quer obter resposta quase que imediata a uma ação.
A classe java.lang.Thread:
A Máquina Virtual Java permite que uma aplicação tenha diversas linhas de execução rodando
concorrentemente. Há sempre pelo menos uma thread, que roda o método main(). Essa
thread é criada automaticamente, e outras podem ser criadas pelo programador.
Em Java, cada thread é implementada como um objeto, que deve ser uma instância de uma
subclasse de java.lang.Thread criada para esse fim. Os comandos a serem executados em
cada linha de execução serão sempre os comandos de um método de nome public void
run(). A classe Thread implementa a interface Runnable, que obriga a ter o método run().
Há duas formas básicas para se criar uma thread:

a) Criar uma subclasse explícita de java.lang.Thread, e redefinir o método run() contendo
os comandos que a thread deverá executar. Na própria classe Thread já existe um método
run() que não faz nada (não é abstrato, apenas não faz nada).
Ex:
class MinhaThread extends Thread{
public void run(){
<instruções da thread>
}
}
A partir daí é possível criar quantas instâncias se desejar dessa classe. Cada vez que
enviar a mensagem start() para uma instância, uma nova linha de execução será iniciada
com os comandos do método run(), que rodará em paralelo com as outras threads:
MinhaThread t = new MinhaThread();

t.start();
ou, simplesmente:
new MinhaThread().start();
Note que não se pode enviar a mensagem run() diretamente para um objeto Thread.
Envia-se a mensagem start(), que criará a thread onde rodarão os comandos do método
run().
Obs: Threads podem ser criadas sem referência explícita, como na forma mais simples
acima ( ex: new MinhaThread().start();) , sem risco de serem removidas pelo Garbage
Collector (coletor de lixo da memória), pois possuem uma referência interna que
permanece até o método run() associado terminar.
b) A segunda forma de criar thread é recomendada em situações onde queremos executar um

método de uma classe qualquer em uma thread separada, sem que essa classe herde de
Thread. Por exemplo, se a classe já for uma subclasse de outra, não poderia herdar
também de Thread. Nesse caso, fazemos a classe em questão implementar a interface
Runnable e colocamos no método public void run() os comandos que serão executados
na thread.
No exemplo abaixo, um método run() da classe X será colocado em uma thread:
class X implements Runnable{
public void run(){

<instruções da thread>
}
..... outros métodos de X, construtores, atributos, etc

}
A seguir, em outro método, criamos uma instância de X, e passamos a instância como

argumento do construtor da classe Thread:
X x = new X(...);
Thread t = new Thread(x);
O efeito disso é a criação de uma instância de Thread que executará o método run()
definido na classe do argumento do construtor.
Enviando a seguir a mensagem start() para essa thread fará iniciar uma nova linha de
execução com os comandos do método run() da classe X, que rodará em paralelo com as
outras threads.
t.start();
Nome da thread:
Toda thread tem um nome (uma string) para poder ser identificada. O nome pode ser passado
como um parâmetro do construtor, e pode ser recuperado enviando para a thread a
mensagem getName(). Se um nome não for especificado no construtor, um novo nome será
gerado automaticamente para a thread.
Como incluir o nome na chamada do construtor:

//subclasse explicita de Thread:
Thread t1 = new MinhaThread("Thread 1");
// usando instancia de classe X que implementa Runnable:

Thread t2 = new Thread(new X(), "Thread 2");
Prioridade:
Cada thread possui uma prioridade. Threads com prioridades mais elevadas são executadas
preferencialmente antes de threads com menor prioridade. A prioridade default é 5 (em uma
escala de 1 a 10), mas pode ser alterada enviando a mensagem setPriority(int) para a
thread. (Nota: na classe Thread existem as constantes static MAX_PRIORITY, MIN_PRIORITY e
NORM_PRIORITY, com valores 10, 0 e 5, mas que podem variar dependendo da
implementação).
Quando existem diversas threads de mesma prioridade sendo executadas, Java aloca um
tempo máximo para processar os comandos de cada uma, após o que interrompe a thread em
execução e passa a processar os comandos da seguinte.
O método de classe Thread.currentThread():
Esse método permite acessar a thread que está executando no momento em que é chamado.
É usado dentro do método run() para permitir identificar e/ou alterar os parâmetros da thread
(lembre-se que o run() pode ser de outra classe). Por exemplo, para imprimir o nome da
thread onde esse comando está executando:
System.out.println(Thread.currentThread().getName());
Interrompendo a execução de uma thread por um intervalo de tempo:
O método de classe Thread.sleep(long milissegundos) permite interromper a execução da

thread pelo tempo dado no argumento.
Deve ser usado dentro de um bloco try porque, caso a thread receba uma mensagem
interrupt() enquanto estiver parada por um sleep(), será lançada uma
InterruptedException.
Cedendo o tempo de processamento para outras threads:

Uma thread pode ceder o restante do tempo de processamento alocado a ela, executando o
comando yield(). O controle passa para os comandos da próxima thread que estiver
aguardando. Evita desperdiçar tempo de processamento.
Exemplos:
1. Duas threads com igual prioridade. Cada uma imprime os 100 primeiros inteiros seguidos
da frase TERMINOU Flamengo! ou TERMINOU Botafogo! Uma thread se chama Flamengo,
e a outra, Botafogo. Após cada linha impressa, a thread "dorme" um número aleatório de
milissegundos (entre 0 e 399) para evitar que o laço de impressão termine antes de se
esgotar a fatia de tempo da thread. O nome é dado pelo argumento passado ao construtor
da thread. O método getName() da classe Thread retorna a string com o nome:
public class ThreadSimples extends Thread {

public ThreadSimples(String str) {
super(str);
}
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i + " " + getName());
try {
sleep((long)(Math.random() * 400));
}
catch (InterruptedException e) {}
}
System.out.println("TERMINOU " + getName()+"!");
}
}
public class TesteDuasThreads {

public static void main (String[] args) {
ThreadSimples bota = new ThreadSimples("BOTAFOGO");
bota.setPriority(4);
ThreadSimples mengo =new ThreadSimples("FLAMENGO");
mengo.setPriority(6);
Thread.currentThread().setPriority(1);
mengo.start();
bota.start();
System.out.println("Main terminado!");
}
}
2. Uso do método yield(). Força passar o controle para a próxima thread que está esperando.
// adaptado do livro 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002
// Uso de yield() em threads.
// No metodo run() o uso de "else yield()" faz com que cada thread
// passe a vez para a proxima thread a cada volta do laco while.
public class YieldingThread extends Thread {
private int contagem = 5; //campo interno de cada thread
// Variável de classe. Contem o numero da proxima instancia a ser criada.

private static int numeroDaThread = 1;
public YieldingThread() {
super("" + numeroDaThread); // o nome da thread eh o seu numero
numeroDaThread++;
start();
}
public String toString() {

return "Thread no." + getName() + ": " + contagem;
}
public void run() {

while (true) {
System.out.println(this);
contagem--;
if (contagem == 0) return;
// sem o yield()o laço terminaria na primeira thread
else yield(); //cede a vez para a proxima thread
}
}
public static void main(String[] args) {

for (int i = 0; i < 5; i++)
new YieldingThread();
}
}
3. Exemplo de uso de sleep()

public class UmaThread extends Thread {
private int delay;
public UmaThread(String id, int delay) {
super(id);
this.delay = delay;
}
public void run() {
try {
sleep(delay);
}
catch(InterruptedException e) {
System.out.println("Thread: " + getName() + " foi interrompida");
}
System.out.println(">>" + getName() + " dormiu " + delay + " miliseg");
}
}
public class MultiThread {

public static void main(String[] args) {
UmaThread t1,t2,t3;
t1 = new UmaThread("Primeira thread",(int)(Math.random()*8000) );
t2 = new UmaThread("Segunda thread", (int)(Math.random()*8000));
t3 = new UmaThread("Terceira thread", (int)(Math.random()*8000));
t1.start();
t2.start();
t3.start();
}
}
Referências:
Sun Java Tutorial – parte dedicada a Threads e processos concorrentes:
Concurrency: http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html

Threads em Java

Enviado por

Direitos autorais:

Formatos disponíveis

Threads em Java

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Threads em Java

Enviado por

Direitos autorais:

Formatos disponíveis

Threads em Java - Introdução revisão em 11/11/2008

Uma thread é um fluxo seqüencial de controle, ou linha de execução, dentro de um processo

Porque usar threads em aplicações:

Há duas formas básicas para se criar uma thread:

MinhaThread t = new MinhaThread();

b) A segunda forma de criar thread é recomendada em situações onde queremos executar um

No exemplo abaixo, um método run() da classe X será colocado em uma thread:

class X implements Runnable{

public void run(){

..... outros métodos de X, construtores, atributos, etc

A seguir, em outro método, criamos uma instância de X, e passamos a instância como

Como incluir o nome na chamada do construtor:

// usando instancia de classe X que implementa Runnable:

Interrompendo a execução de uma thread por um intervalo de tempo:

O método de classe Thread.sleep(long milissegundos) permite interromper a execução da

Cedendo o tempo de processamento para outras threads:

public class ThreadSimples extends Thread {

public class TesteDuasThreads {

// Variável de classe. Contem o numero da proxima instancia a ser criada.

public String toString() {

public void run() {

public static void main(String[] args) {

3. Exemplo de uso de sleep()

public class MultiThread {

Você também pode gostar