Java Thread State Introdução com Exemplo - Ciclo de Vida de um Thread

Estados do Tópico

O diagrama a seguir ilustra os vários estados em que um thread Java pode estar em qualquer ponto de sua vida e quais chamadas de método causam uma transição para outro estado. Este diagrama não é um diagrama de estado finito completo, mas sim uma visão geral das facetas mais interessantes e comuns da vida de um thread.

Você está no lugar certo se tiver alguma das perguntas abaixo:

• Ciclo de vida de um thread em Java
• Ciclo de vida e estados de um thread em Java
• Entendendo os estados de thread Java

O restante desta página discute Thread's life cycle em termos de seu estado.

Novo tópico

A instrução a seguir cria um novo thread, mas não o inicia, deixando o thread no estado rotulado como New Thread no diagrama.

Quando um thread está no estado New Thread , ele é meramente um objeto Thread vazio. Nenhum recurso do sistema foi alocado para ele ainda. Assim, quando um encadeamento está neste estado, você só pode iniciar o encadeamento ou pará-lo; chamar qualquer outro método além de start() ou stop() quando um thread está nesse estado não faz sentido e causa um IllegalThreadStateException.

Executável

Agora considere estas duas linhas de código:

O método start() cria os recursos do sistema necessários para executar a thread, agenda a execução da thread e chama o método run() da thread. Neste ponto, o thread está no estado "Executável". Esse estado é chamado de "Executável" em vez de "Em execução" porque o thread pode não estar realmente em execução quando estiver nesse estado. Muitos computadores têm um único processador, tornando impossível executar todos os threads “Runnable” ao mesmo tempo.

Portanto, o sistema de tempo de execução Java deve implementar um esquema de agendamento que compartilhe o processador entre todas as threads “Executáveis”. No entanto, para a maioria dos propósitos, você pode pensar no estado “Runnable” como simplesmente “Running”. Quando um encadeamento está em execução – é “Executável” e é o encadeamento atual – as instruções em seu run() estão sendo executadas sequencialmente.

Não executável

Um encadeamento entra no estado Not Runnable quando ocorre um destes quatro eventos:

• alguém chama seu método suspend()
• alguém chama seu método sleep()
• a thread usa seu método wait() para esperar em uma variável de condição
• o encadeamento está bloqueando na E/S.

Por exemplo, a linha em negrito neste snippet de código

coloca myThread para dormir por 10 segundos (10.000 milissegundos). Durante esses 10 segundos, mesmo que o processador ficasse disponível, myThread não seria executado. Após os 10 segundos, myThread torna-se “Runnable” novamente e agora, se o processador estiver disponível, myThread será executado.

Para cada uma das “entradas” no estado “Não executável” listado acima, há uma rota de escape específica e distinta que retorna o encadeamento ao estado “Executável”. Uma rota de fuga só funciona para sua “entrada” correspondente. Por exemplo, se um encadeamento foi colocado em suspensão, o número especificado de milissegundos deve decorrer antes que o encadeamento se torne “Executável” novamente. Chamar resume() em um thread adormecido não tem efeito.

O seguinte indica a rota de fuga para cada entrada no estado “Não executável”.

• Se um thread foi colocado em suspensão, o número especificado de milissegundos deve decorrer.
• Se um thread foi suspenso, alguém deve chamar seu método resume() .
• Se um encadeamento estiver aguardando uma variável de condição, qualquer objeto que possua a variável deve liberá-la chamando notify() ou notifyAll() .
• Se um encadeamento estiver bloqueado na E/S, o comando de E/S especificado deverá ser concluído.

Morta

Um thread pode morrer de duas maneiras: por causas naturais ou por ser morto (parado). Um thread morre naturalmente quando seu método run() sai normalmente. Por exemplo, o laço while neste método é um laço finito – ele irá iterar 100 vezes e depois sair.

Um encadeamento com este método run() morrerá naturalmente após o loop e o método run() concluídos.

Você também pode matar um thread a qualquer momento chamando seu método stop() . Este trecho de código.

cria e inicia myThread , em seguida, coloca o thread atual em suspensão por 10 segundos. Quando o thread atual é ativado, a linha em negrito no segmento de código mata myThread .

O método stop() lança um objeto ThreadDeath no encadeamento para eliminá-lo. Assim, quando um thread é morto dessa maneira, ele morre de forma assíncrona. O thread morrerá quando ele realmente receber a exceção ThreadDeath.

IllegalThreadStateException

O sistema de tempo de execução lança um IllegalThreadStateException quando você chama um método em um thread e o estado desse thread não permite essa chamada de método. Por exemplo, IllegalThreadStateException é lançada quando você chama suspend() em um thread que não é “Runnable”.

Conforme mostrado nos vários exemplos de encadeamentos até agora nesta lição, quando você chama um método de encadeamento que pode lançar uma exceção, você deve capturar e manipular a exceção ou declarar que o método de chamada lança a exceção não capturada.

O método isAlive()

E uma palavra final sobre o estado da thread: a interface de programação para a classe Thread inclui um método chamado isAlive() . O isAlive() retorna true se o thread foi iniciado e não parado. Assim, se o método isAlive() retornar false , você saberá que o thread é um “New Thread” ou “Dead”.

Se o método isAlive() retornar true , você saberá que o encadeamento é “Runnable” ou “Not Runnable”. Você não pode diferenciar entre um “Novo Tópico” e um Tópico “Morto”; nem você pode diferenciar entre um thread “Executável” e um thread “Não Executável”.

Ao olhar para exemplos de threads complexos, encontrei este ótimo tutorial na rede. Todos deveriam ler isso com atenção.