Introdução detalhada ao ciclo de vida dos threads java e código de exemplo

Quando um tópico é criado e iniciado, ele não entra no estado de execução assim que é iniciado nem sempre no estado de execução. Durante seu ciclo de vida, ele tem que passar por cinco estados: "Novo", "Runnable", "Running", "Blocked" e "Dead". Depois que o tópico é criado, é impossível ocupar a CPU e correr de forma independente. Ele precisa alternar entre vários threads, para que seja alternada entre a execução e o bloqueio na maioria das vezes.

1. O estado do tópico

Existem vários estados diferentes da existência de um tópico, como segue:

1. Novo status
2. Status pronto
3. Status de corrida
4. Status morto
5. Status não executável
   

1. Novo status

O novo estado é um estado em que o tópico foi criado, mas não começou a funcionar. Este estado permite que o encadeamento seja executado chamando o método START () do thread.

2. Status executável

O estado executável pode ser chamado de estado de corrida preparatório ou fila. Esse estado pode permitir que o encadeamento seja executado chamando o método START () do thread.
O agendador de thread determina quais threads executam e quanto tempo o thread será executado.

3. Status de corrida

Se um thread estiver executando, ele está no estado de corrida.

4. Estado morto

Depois que um tópico entra no estado morto, ele não pode mais correr.

5. Status não executável

1. Um fio em execução pode ser transformado no estado não executável, dependendo da situação em execução.
2. Um encadeamento também pode manter o estado não executável até que a condição satisfeita apareça.
3. Um tópico com um estado não executável não pode pular diretamente para o estado em execução, mas deve primeiro ser convertido no estado executável.
4. Dormindo: o tempo especificado para o sono de threads.
5. Bloqueio de E/S: o thread aguarda até que a operação de bloqueio seja concluída.
6. Junte -se ao bloqueio: o thread aguarda até que outro thread seja executado.
7. Aguardando a notificação: o thread está aguardando notificação de outro thread.
8. Mecanismo de bloqueio Bloqueio: a rosca espera até que a trava especificada seja liberada e a trava seja obtida.

A Java Virtual Machine JVM executa threads de acordo com os princípios de prioridade e agendamento do thread.

2. Agendador de thread

Na JVM, a implementação do agendador de threads geralmente é baseada nas duas estratégias a seguir:

Estratégia de agendamento preventivo Estratégia de agendamento de tempo de compartilhamento ou estratégia de agendamento de Round-Robin

A implementação de um agendador de threads é independente da plataforma, portanto, o agendamento de threads é imprevisível.

3. Prioridade dos threads

A JVM atribui uma prioridade a cada thread recém -criado.

Nível 0: esta é a menor prioridade
Nível 5: esta é a prioridade normal
Nível 10: esta é a maior prioridade

Para salvar esses valores, a classe Thread possui três variáveis ​​correspondentes:

1. public static final int min_priority
2. public static final int norm_priority
3. public static final int max_priority

Um thread herdará primeiro a prioridade de seu thread pai. A prioridade padrão de cada encadeamento é o nível 5 (prioridade normal) e a prioridade padrão do encadeamento principal é o nível 5.

A prioridade do thread pode ser definida através do método SetPriority (Int Priority).

Public Final Void SetPriority (Int Priority)
public void getPriority ();

Um thread definido pelo usuário possui um thread de thread padrão+ número de sequência, e o número da sequência é iniciado a partir de 0, como o primeiro thread é Thread0.
O nome do thread pode ser definido através do método setName (Nome da String), e o nome do thread pode ser obtido usando o método getName ().

Public Final Void SetName (Nome da String)
Public Final String getName ().

Exemplo

Vamos ver um exemplo abaixo:

 pacote Demo.ch; public class UserThread Extende Thread {userThread () {super (); } UserThread (nome da string) {super (nome); } public void run () {System.out.println ("Thread começou a executar .."); } public static void main (string [] args) {userThread thread1 = new UserThread ("Thread1"); UserThread Thread2 = new UserThread ("Thread2"); System.out.println ("Thread 1 Nome e prioridade inicial"); System.out.println ("Nome:" + Thread1.getName ()); System.out.println ("Prioridade:" + Thread1.getPriority ()); System.out.println ("Nome e prioridade do thread 2"); System.out.println ("Nome:" + Thread2.getPriority ()); System.out.println ("Prioridade:" + Thread2.getPriority ()); System.out.println (""); Thread1.setPriority (6); Thread2.setPriority (9); System.out.println ("Thread 1 Nome e prioridade inicial"); System.out.println ("Nome:" + Thread1.getName ()); System.out.println ("Prioridade:" + Thread1.getPriority ()); System.out.println ("Nome e prioridade do thread 2"); System.out.println ("Nome:" + Thread2.getName ()); System.out.println ("Prioridade:" + Thread2.getPriority ()); System.out.println (""); Thread1.start (); Thread2.start (); for (int i = 0; i <5; i ++) System.out.println ("Método principal I valor:"+i); }}

Resultado da saída:

 Tópico 1 Nome inicial e prioridade Nome: Thread1Prioridade: 5Thread 2 Nome inicial e Nome da prioridade: Thread2Prioridade: 5thread 1 Nome inicial e Nome da prioridade: Thread1Prioridade: 6Thread 2 Nome inicial e Nome da prioridade: Métodos de linha: Método: MÉTODO INFEITO: MÉTODO DO MÉTODO: MÉTODO: MÉTODO DO MÉTODO: MÉTODO: MÉTODO DO MÉTODO 2THELET: MÉTODO DO MÉTODO: MÉTODO DO MÉTODO 2 2THENAIN 2THENAIN: MÉTODO DO MÉTODO 2 2THENAIN 2THENAIN: Método.

Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!