Introdução a Thread na linguagem JAVA

...

Se você executar o programa, poderá ver que a bola quica normalmente, mas assume o controle completo do aplicativo. Se você cansar da bola quicando antes que ela faça isso 1000 vezes e se der um clique no botão “Close”, a bola continuará a quicar. Você não pode interagir com o programa até que a bola tenha terminado de quicar.

Essa não é uma boa situação na teoria ou na prática e está se tornando cada vez mais problemático à medida que as redes se tornam mais importantes. Afinal, quando

---------------------------------------------------------------

você está lendo dados através de uma conexão de rede, é muito comum ficar preso em uma tarefa demorada que você gostaria realmente de interromper. Por exemplo, suponha que você descarregue uma imagem grande e decida, após ver uma parte dela, que não precisa ou não quer ver o restante; você certamente gostaria de poder dar um clique em um botão “Parar” ou “Voltar” para interromper o processo de download.

Vide o código Bounce.Java.

Usando Linhas de Execução para das uma chance às outras tarefas

Tornaremos nosso programa da bola que quica mais responsivo, executando o código que move a bola uma linha de execução separada.

Em nosso próximo programa, usamos duas linhas de execução : uma para a bola que quica e outra para a linha de execução principal, que cuida da interface com o usuário. Como cada linha de execução tem uma chance de ser executada, a linha de execução principal tem a oportunidade de notar quando você dá um clique no botão “Close”, enquanto a bola está quicando. Ele pode então processar a ação de “fechamento”.

Existe um procedimento simples para executar o código em uma linha de execução separada: insira o código no método run de uma classe derivada de Thread.

Para fazer nosso programa da bola que quica em uma linha de execução separada, precisamos apenas de derivar Ball e Thread e renomear o método bounce como run, como no código a seguir:

class Ball extends Thread {

public run() {

try {

draw();

for(int i = 1; i

move();

sleep(5);

}

} catch(InterruptedException e() {}

}

}

Você pode ter notado que estamos capturando uma exceção chamada InterruptedException. Métodos como sleep e wait lançam essa exceção quando sua thread é interrompida, em função de outra linha de execução ter chamado o método interrupt. A interrupção de uma linha de execução é um modo muito drástico para obter a atenção da linha de execução, mesmo quando ela não está ativa. Normalmente, uma

---------------------------------------------------------------

linha de execução é interrompida para ser finalizada. Dessa maneira, nosso método run termina quando ocorre uma InterruptException.

Executando e iniciando linhas de execução

Quando você constrói um objeto derivado de Thread, o método run não é chamado automaticamente.

Ball b = new Ball(...); // não será executado ainda

Você deve chamar o método start em seu objeto, para realmente iniciar uma linha de execução.

b.start();

Na linguagem de programação Java, uma linha de execução precisa dizer às outras linhas de execução quando está ociosa, para que as outras linhas de execução tenham a chance de executar o código de seus procedimentos run. O modo normal de fazer isso é atracés do método estático sleep. O método run da classe Ball usa a chamada a sleep(5) para indicar que a linha de execução ficará ociosa pelos próximos 5 milissegundos. Após

5 milissegundos ela será iniciada novamente, mas nesse meio tempo, outras linhas de execução têm uma chance de fazer seu trabalho.

Do ponto de vista do projeto, parece estranho fazer a classe Ball estender a classe Thread. Uma bola (Ball) é um objeto que se move na tela e quica nos campos. Há uma plicação de regra de herança aqui? Uma bola é linha de execução? Na verdade, não. Aqui, estamos usando herança por razões estritamente técnicas. Para obter uma linha de execução que possa controler, você precisa de um objeto thread com um método run. Também poderíamos incluir esse método run na classe cujos métodos e campos de instância o método run utiliza. Portando, tornamos Ball uma classe filha de Thread. Além disso, isso torna o exemplo mais fácil de entender: todo objeto Bal que você constrói e inicia, executa seu método run em sua própria linha de execução. Posteriormente você verá como pode usar a interface Tunnable para não precisar extender a classe Thread.

Vide o código BounceThread.java.

Executando diversas linhas de execução

Execute o programa BounceThread. Agora, clique no botão “Start” novamente, enquanto a bola está se movendo. Clique nele mais algumas vezes. Você verá diversas bolas quicando. Cada bola se moverá 1000 vezes, até chagar à sua posição filan de repouso.

Esse exemplo demostra uma grande vantagem da arquitetura de linhas de execução na linguagem de programação Java. É muito fácil criar qualquer número de objetos autônomos, que parecem ser executados em paralelo.

---------------------------------------------------------------

Propriedades de linhas de execução

Estados de linha de execução

As linhas de execução podem estar em um dos quatro estados:

• nova

• passível de execução

• bloqueada

• morta

Cada