Entenda tópicos
conceito
Um thread é o thread de execução no programa. A máquina virtual Java permite que os aplicativos executem vários threads de execução simultaneamente.
Recursos de thread
Tem um estado, que representa o estado de um fio. Ao mesmo tempo, um tópico na JVM tem apenas um estado;
·NOVO
Tópicos que ainda não foram iniciados (tópicos que não foram iniciados desde o início da execução do programa)
・ Runnable
Um encadeamento executável que está em execução na JVM, mas pode estar esperando por outros recursos, como a CPU.
·BLOQUEADO
Bloqueando o fio, esperando uma fechadura para permitir que ela continue correndo
·ESPERANDO
Espere infinito (corra novamente em um tópico que depende de deixá -lo entrar nesse estado para executar uma operação específica)
・ Timed_waiting
Esperando cronometrado (execute novamente em um tópico que depende de deixá -lo entrar nesse estado para uma operação específica dentro de um tempo de espera especificado)
・ Encerrado
Tópico de saída
Ter prioridade e determine a ordem de execução dos threads;
Um número inteiro entre 1 e 10, o valor padrão é 5. Quanto maior o valor, maior a chance de execução e a prioridade não determina a ordem de execução do encadeamento.
A prioridade do encadeamento infantil é a mesma do thread pai por padrão.
Observe que a JVM deixará de executar todos os threads quando:
O método EXIT () do tempo de execução (tempo de execução) é chamado e a chamada do método é permitida pelo gerenciador de segurança;
Todos os "threads não daemon" pararam de funcionar (independentemente de pararem normalmente ou uma parada);
Pode ser marcado como um daemon (daemon)
O fio infantil do fio daemon ainda é o fio daemon;
O thread Daemon também é o "thread de back-end", que geralmente é usado para executar tarefas de fundo, enquanto o thread do usuário geralmente executa tarefas no nível do usuário.
Métodos para encerrar o thread
1. Use o sinalizador de saída para fazer a saída do encadeamento normalmente, ou seja, o thread termina após a conclusão do método de execução.
Quando o método de execução é executado, o thread sairá. Mas às vezes o método de corrida nunca termina. Por exemplo, o uso de threads para ouvir solicitações de clientes em programas de servidor ou outras tarefas que exigem processamento de loop. Nesse caso, essas tarefas geralmente são colocadas em um loop, como o loop enquanto o loop. Se você deseja que o loop seja executado para sempre, pode usar enquanto (true) {...} para lidar com isso. No entanto, se você deseja fazer a saída do loop no tempo em uma certa condição, a maneira mais direta é definir um sinalizador do tipo booleano e controlar se o loop de tempo sai definindo esse sinalizador como true ou falso. Aqui está um exemplo de encerrar um encadeamento usando o sinalizador de saída.
FlagexitThread.java
pacote com.rainmonth;/*** criado por Randyzhang em 2017/3/23.
Democlient.java
pacote com.rainmonth;/*** criado por Randyzhang em 2017/3/23. = new FlagexitThread (flagexitThread.class.getSimpleName ()); FLAGEXITTHREAD.START (); TRY {Thread.sleep (1000); flagexitThread.isexit = true; flagexitThread.Join (); System.out.Println ("Thread"; {E.PrintStackTrace ();}} private estático void exitbyInterrupt () {flagexitThread flagexitThread = new FlagexitThread (flagexitThread.class.getSimplename (); System.out.println ("FlagexitThread Ranking ..."); {Thread.sleep (1500); System.out.println ("FlagexitThread interrompido ..."); FlagexitThread.Interrupt (); Thread.sleep (1500); System.out.println ("Stop Application ...");} Catch (interruptException E) {E.PrintTack ();Resultado da saída:
Imprima um monte de que estou correndo após as saídas do thread.
2. Use o método de parada para encerrar com força o encadeamento (esse método não é recomendado, porque a parada é a mesma que suspensa e retomar e também pode ter resultados imprevisíveis).
Mostra o método de stop de chamada (). A descrição de Stop () no código -fonte é a seguinte:
/** Este método é inerentemente inseguro. Interromper um thread com* Thread.stop faz com que ele desbloqueie todos os monitores que ele* bloqueou (como uma conseqüência natural da exceção* <code> threadDeath </code> não controlada). Se* algum dos objetos previamente protegidos por esses monitores estava em um estado inconsistente, os objetos danificados se tornam visíveis para* outros threads, potencialmente resultando em comportamento arbitrário. Muitos* usos de <code> stop </code> devem ser substituídos pelo código que simplesmente* modificam alguma variável para indicar que o thread de destino deve* parar de funcionar. O thread de destino deve verificar essa variável* regularmente e retornar de seu método de execução de maneira ordenada* se a variável indicar que é parar de funcionar. Se o thread de destino aguardar períodos longos (em uma variável de condição,* por exemplo), o método <code> interrompe </code> deve ser usado para* interromper a espera.*/
O significado geral é que a insegurança do método é inerente. Chamando STOP () para encerrar um encadeamento liberará todos os monitores que ele bloqueou (isso fará com que a exceção do ThreadDeath se propagasse para cima ao longo da pilha a ser verificada para ser jogada). Se houver inconsistência em objetos previamente protegidos por esses monitores liberados e esses objetos estiverem visíveis para outros threads, isso levará a algumas consequências inesperadas. O que deve parar as operações são substituídas pelo código que só precisa modificar determinado código para indicar que o encadeamento de destino deve parar de funcionar (o método 1 é assim). Se o thread de destino aguardar uma determinada condição (como uma determinada variável de condição) por um longo tempo, devemos usar o método de interrupção para interromper a espera (este é o método do método 3).
3. Use o método de interrupção para interromper o thread.
A interrupção significa literalmente terminando, mas não tente encerrar o thread chamando interrupção, porque às vezes mesmo se você chamar o método, o thread continuará sendo executado. Você pode comentar o ExitbyFlag () acima, ativar o método ExitByInterrupt () e descobrir que o método interrupto () é chamado no tempo e estou em execução ... (os resultados de diferentes sistemas e CPUs podem ser diferentes). Pode -se observar que não é seguro usar o método de interrupção.
Resumir
De acordo com a análise acima, o método mais recomendado é o primeiro. Podemos definir sinalizadores usando variáveis compartilhadas e enviar sinais para informar o tópico que ele deve terminar. Obviamente, devemos garantir que as operações dessa variável compartilhada sejam síncronas.
O exposto acima é todo o conteúdo deste artigo sobre a instância do thread de terminação Java e a leitura do código -fonte do método STOP (). Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!