Assim como as pessoas nascem, envelhecem, adoecem e morrem, os fios também passam por quatro estados diferentes: iniciar (esperar), correr, pendurar e parar. Esses quatro estados podem ser controlados por meio de métodos da classe Thread. Os métodos relacionados a esses quatro estados na classe Thread são fornecidos abaixo.
// Suspender e ativar threads
public void resume() // Não recomendado para uso
public void suspend() // Não recomendado para uso
sono vazio estático público (milissegundos longos);
sono vazio estático público (milis longos, nanos int);
//Termina o tópico
public void stop() // Não recomendado para uso
interrupção nula pública ( );
// Obtém o status do tópico
público booleano isAlive();
público booleano isInterrupted();
público estático booleano interrompido();
// método de junção
public void join() lança InterruptedException;
O thread não executa o código no método run imediatamente após ser estabelecido, mas está em estado de espera. Quando o thread está no estado de espera, você pode definir vários atributos do thread por meio dos métodos da classe Thread, como a prioridade do thread (setPriority), o nome do thread (setName) e o tipo de thread (setDaemon).
Quando o método start é chamado, o thread começa a executar o código no método run. O thread entra no estado de execução. Você pode usar o método isAlive da classe Thread para determinar se o thread está em execução. Quando o thread está no estado de execução, isAlive retorna verdadeiro. Quando isAlive retorna falso, o thread pode estar no estado de espera ou no estado parado. O código a seguir demonstra a alternância entre os três estados de criação, execução e parada do thread e gera o valor de retorno isAlive correspondente.
classe pública LifeCycle estende Thread
{
execução de vazio público ()
{
interno n = 0;
enquanto ((++n) <1000);
}
public static void main(String[] args) lança exceção
{
Thread1 do Ciclo de Vida = new Ciclo de Vida();
System.out.println("isAlive: " + thread1.isAlive());
thread1.start();
System.out.println("isAlive: " + thread1.isAlive());
thread1.join(); // Aguarde o thread thread1 terminar antes de continuar a execução
System.out.println("thread1 terminou!");
System.out.println("isAlive: " + thread1.isAlive());
}
}
O resultado da execução do código acima:
Depois que o thread começar a executar o método run, ele não será encerrado até que o método run seja concluído. No entanto, durante a execução do thread, existem dois métodos que podem ser usados para interromper temporariamente a execução do thread. Esses dois métodos são suspender e dormir. Depois de usar suspender para suspender o thread, você pode ativá-lo por meio do método resume. Depois de usar sleep para fazer o thread dormir, o thread só pode estar no estado pronto após o tempo definido (após o término do sono do thread, o thread pode não ser executado imediatamente, mas apenas entra no estado pronto, aguardando o agendamento do sistema) .
Embora suspender e retomar possam suspender e ativar threads facilmente, o uso desses dois métodos pode causar a ocorrência de algumas coisas imprevisíveis. Portanto, esses dois métodos são marcados como obsoletos (protesto), o que indica que esses dois métodos podem ser excluídos no futuro jdk. versões, então tente não usar esses dois métodos para operar threads. O código a seguir demonstra o uso dos métodos sleep, suspend e resume.
classe pública MyThread estende Thread
{
classe SleepThread estende Thread
{
execução de vazio público ()
{
tentar
{
dormir(2000);
}
pegar (Exceção e)
{
}
}
}
execução de vazio público ()
{
enquanto (verdadeiro)
System.out.println(new java.util.Date().getTime());
}
public static void main(String[] args) lança exceção
{
thread MyThread = new MyThread();
SleepThread sleepThread = thread.new SleepThread();
sleepThread.start(); // Inicia a execução do thread sleepThread
sleepThread.join(); // Atrasa o thread sleepThread por 2 segundos
thread.start();
sinalizador booleano = falso;
enquanto (verdadeiro)
{
sleep(5000); // Atrasa o thread principal por 5 segundos
bandeira = !bandeira;
se (bandeira)
thread.suspend();
outro
thread.resume();
}
}
}
Há dois pontos a serem observados ao usar o método sleep:
1. O método sleep tem duas formas sobrecarregadas. Uma das formas sobrecarregadas pode definir não apenas milissegundos, mas também nanossegundos (1.000.000 nanossegundos é igual a 1 milissegundo). No entanto, a máquina virtual Java na maioria das plataformas de sistema operacional não tem precisão de nanossegundos. Portanto, se os nanossegundos forem configurados para suspensão, a máquina virtual Java usará o milissegundo mais próximo desse valor.
2. Ao usar o método sleep, você deve usar throws ou try{…}catch{…} Como o método run não pode usar throws, você só pode usar try{…}catch{…}. lançará uma InterruptedException ao interromper um thread usando o método de interrupção (este método será discutido em 2.3.3). O método sleep é definido da seguinte forma:
Existem três maneiras de encerrar um thread.
1. Use o sinalizador de saída para fazer o thread sair normalmente, ou seja, o thread termina quando o método de execução é concluído.
2. Use o método stop para encerrar o thread à força (esse método não é recomendado porque parar, assim como suspender e retomar, também pode produzir resultados imprevisíveis).
3. Use o método de interrupção para interromper o thread.
1. Encerre o thread usando o sinalizador de saída
Quando o método run for executado, o thread será encerrado. Mas às vezes o método run nunca termina. Por exemplo, threads são usados em programas de servidor para monitorar solicitações de clientes ou outras tarefas que requerem processamento cíclico. Nesse caso, essas tarefas geralmente são colocadas em um loop, como um loop while. Se você quiser que o loop seja executado para sempre, você pode usar while(true){...} para lidar com isso. Mas se você quiser fazer o loop while sair sob uma determinada condição, a maneira mais direta é definir um sinalizador do tipo booleano e definir esse sinalizador como verdadeiro ou falso para controlar se o loop while será encerrado. Um exemplo de encerramento de um thread usando o sinalizador de saída é fornecido abaixo.
classe pública ThreadFlag estende Thread
{
saída booleana volátil pública = falso;
execução de vazio público ()
{
enquanto (!sair);
}
public static void main(String[] args) lança exceção
{
ThreadFlag thread = new ThreadFlag();
thread.start();
sleep(5000); //O thread principal atrasa 5 segundos
thread.exit = true; // Encerrar thread
thread.join();
System.out.println("Tópico encerrado!");
}
}
2. Use o método stop para encerrar o thread
Use o método stop para encerrar à força um thread em execução ou suspenso. Podemos usar o seguinte código para encerrar o thread:
3. Use o método de interrupção para encerrar o thread
O uso do método de interrupção para encerrar um thread pode ser dividido em duas situações:
(1) O thread está em um estado bloqueado, como usar o método sleep.
(2) Use while(!isInterrupted()){...} para determinar se o thread foi interrompido.
No primeiro caso, usando o método de interrupção, o método sleep lançará uma exceção InterruptedException, enquanto no segundo caso o thread será encerrado diretamente. O código abaixo demonstra o uso do método de interrupção no primeiro caso.
classe pública ThreadInterrupt estende Thread
{
execução de vazio público ()
{
tentar
{
sleep(50000); //atraso 50 segundos
}
pegar (InterruptedException e)
{
System.out.println(e.getMessage());
}
}
public static void main(String[] args) lança exceção
{
Thread thread = new ThreadInterrupt();
thread.start();
System.out.println("Pressione qualquer tecla dentro de 50 segundos para interromper o thread!");
System.in.read();
thread.interrupt();
thread.join();
System.out.println("O thread foi encerrado!");
}
}
sono interrompido
O tópico foi encerrado!
Nota: Existem dois métodos na classe Thread para determinar se o thread será encerrado por meio do método de interrupção. Um é o método estático interrompido() e o outro é o método não estático isInterrupted(). A diferença entre esses dois métodos é que interrompido é usado para determinar se o thread atual é interrompido, enquanto isInterrupted pode ser usado para determinar se. outros threads são interrompidos. Portanto, while (!isInterrupted()) também pode ser substituído por while (!Thread.interrupted()).