Copie o código do código da seguinte forma:
//Iniciar tópico
início vazio público ( );
execução nula pública ( );
// 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;
1. Crie e execute threads
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.
Copie o código do código da seguinte forma:
pacote capítulo2;
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());
}
}
Observe que o método join é usado no código acima. A principal função deste método é garantir que o programa continue a ser executado após a conclusão do método de execução do thread.
O resultado da execução do código acima:
isAlive: falso
isAlive: verdadeiro
tópico1 terminou!
isAlive: falso
2. Suspender e ativar tópicos
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, você pode interromper temporariamente a execução do thread por meio de dois métodos. Esses dois métodos são suspender e dormir. Depois de usar suspend para suspender um 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.
Copie o código do código da seguinte forma:
pacote capítulo2;
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();
}
}
}
Superficialmente, os efeitos do uso de dormir e suspender são semelhantes, mas o método dormir não é equivalente a suspender. A maior diferença entre eles é que você pode suspender outro thread em um thread por meio do método suspend. Por exemplo, no código acima, o thread do thread é suspenso no thread principal. Sleep só funciona no thread atualmente em execução. No código acima, sleepThread e o thread principal dormem por 2 segundos e 5 segundos, respectivamente. Ao usar sleep, esteja ciente de que você não pode suspender um thread em outro thread. Por exemplo, usar o método thread.sleep(2000) no método principal não pode fazer o thread hibernar por 2 segundos, mas só pode fazer o thread principal hibernar por 2 segundos.
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. Throws ou try{...}catch{...} devem ser usados ao usar o método sleep. Como o método run não pode usar throws, você só pode usar try{...}catch{...}. Quando o thread está em suspensão e o método de interrupção (este método será discutido em 2.3.3) é usado para interromper o thread, sleep lançará uma InterruptedException. O método sleep é definido da seguinte forma:
Copie o código do código da seguinte forma:
public static void sleep (long milis) lança InterruptedException
public static void sleep (long milis, int nanos) lança InterruptedException
3. Três maneiras de encerrar um tópico
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 certas condições, 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.
Copie o código do código da seguinte forma:
pacote capítulo2;
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!");
}
}
Um sinalizador de saída, exit, é definido no código acima. Quando exit é verdadeiro, o loop while termina e o valor padrão de exit é falso. Ao definir a saída, uma palavra-chave Java volátil é usada. O objetivo desta palavra-chave é sincronizar a saída, o que significa que apenas um thread pode modificar o valor da saída ao mesmo tempo.
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:
thread.stop();
Embora o uso do código acima possa encerrar o thread, usar o método stop é muito perigoso. Assim como desligar o computador repentinamente em vez de desligá-lo de acordo com o procedimento normal, pode produzir resultados imprevisíveis. o método stop.
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.
Copie o código do código da seguinte forma:
pacote capítulo2;
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!");
}
}
Os resultados da execução do código acima são os seguintes:
Copie o código do código da seguinte forma:
Pressione qualquer tecla dentro de 50 segundos para interromper o tópico!
sono interrompido
O tópico foi encerrado!
Depois de chamar o método de interrupção, o método sleep lança uma exceção e então exibe a mensagem de erro: sleep interrompido.
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()).