Às vezes, os pendores de threads são úteis. Por exemplo, um encadeamento separado pode ser usado para exibir a hora do dia. Se o usuário não quiser usar o relógio, o thread será suspenso. De qualquer forma, suspender o encadeamento é muito simples e, uma vez suspenso, reiniciar o encadeamento também é uma questão simples.
Os mecanismos para suspender, encerrar e restaurar os threads diferem nas versões Java 2 e anteriores. Embora você use o Java 2 para escrever código, ainda precisa entender como essas operações foram realizadas no ambiente Java Early. Por exemplo, pode ser necessário atualizar ou manter o código antigo. Você também precisa entender por que o Java 2 tem essas mudanças. Por esses motivos, a seguir descreve o método original de executar o controle do encadeamento, seguido pelo método Java 2.
Pausa, recuperação e rescisão de threads em java 1.1 ou anterior
Antes da versão Java2, o programa usa o Suspender () e o currículo () para pausar e reiniciar os threads. Eles estão na forma de:
Final Void Suspender () Final Void Rumum ()
O procedimento a seguir descreve estes métodos:
// Usando suspensão () e resume (). out .println ("novo thread:" T); i> 0; "::::::::::::::::::::::::Hee ::::::::::::::::::heone :::::::::::::::::he::: ::::::::::::::); NewthRead (One "); .Sleep (1000); sono (1000); Aguarde o threads, tente {System.out.println ("Aguardar threads terminar."); Println ("Tópico principal interrompido"); Parte da saída do programa é a seguinte:
Novo Tópico: Tópico [Um, 5, Main] One: 15New Thread: Thread [dois, 5, Main] dois: 15ONE: 14TWO: 14ONE: 13TWO: 13ONE: 12TWO: 11TWO: 11Suspending Thread Onetwo: 10two: 9two: 8two: 7TWO: 6 RESUMO DE TRANSPESSÃO DESPENDIDAS DO TODO: 10ONE: 9ONE: 8ONE: 7ONE: 6 RESUMING TRANSPESSO TWOWAITING PARA THREAS PARA FINAR. .Main Thread saindo.
A classe Thread também define parada () para encerrar o thread. Sua forma é a seguinte:
Void Stop ()
Depois que o thread é encerrado, ele não pode ser retomado pelo currículo () para continuar em execução.
Suspender, restaurar e encerrar fios em java
Os métodos de suspensão (), currume () e stop () definidos por threads parecem ser maneiras perfeitas e convenientes de gerenciar threads e não podem ser usados em novas versões de programas Java. Aqui estão as razões. O método suspense () da classe Thread não é favorecido no Java2, porque o suspensão () às vezes pode causar falhas graves do sistema. Supondo que um encadeamento para uma estrutura de dados crítico seja bloqueado, se o thread for suspenso lá, os encadeamentos bloqueados não desistem do controle do recurso. Outros tópicos que aguardam esses recursos podem estar em impasse.
O método currume () também não é aprovado. Não causa problemas, mas não pode ser usado de forma independente sem o método suspense (). O método Stop () da classe Thread também se opõe ao Java 2. Isso ocorre porque esse método pode causar falhas graves do sistema. Imagine um thread está escrevendo uma estrutura de dados precisa e importante e completando apenas uma fração dele. Se o thread terminar neste momento, a estrutura de dados poderá permanecer em um estado de colisão.
Como os métodos Java 2, suspense (), currume () e Stop () não podem ser usados para controlar os threads, você pode pensar que não há como parar, restaurar e encerrar threads. Na verdade, não é o caso. Em vez disso, o thread deve ser projetado para que o método run () verifique periodicamente para determinar se o thread deve ser suspenso, retomar ou encerrar sua própria execução. Representativamente, isso é feito estabelecendo uma variável de sinalizador indicando o estado do thread. Enquanto o sinalizador estiver definido como "Running", o método run () deve continuar sendo executado pelo thread. Se a bandeira estiver "suspensa", o tópico deverá ser pausado. Se definido como "parar", o thread deve ser encerrado.
Obviamente, existem muitas maneiras de escrever esse código, mas o tópico central deve ser o mesmo para todos os programas.
Os exemplos a seguir ilustram como os métodos wait () e notify () herdados do controle de objetos a execução dos threads. Este exemplo é muito semelhante ao programa mencionado anteriormente. No entanto, nenhum dos métodos que não são aprovados são úteis. Vamos pensar sobre a execução do programa.
A classe NewTread contém a variável de instância SustendFlag usada para controlar a execução de um thread. É inicializado para false pelo construtor. O método RUN () contém um bloco que monitora a declaração de sincronização do SustendFlag. Se a variável for verdadeira, o método wait () será chamado para suspender o thread. O método mysuspend () define o suspenderflag como true. O método myResume () define o suspenderflag como false e chama o método notify () para evocar o thread. Finalmente, o método Main () é modificado para chamar os métodos MysusPend () e MyResume ().
// suspender e recuperar um thread para java2class newthread implementos runnable {nome da string; OUT .Println ("novo thread:" T); t i = 15; }}} Catch (interrompida e) {System.out.println (nome + "interrompido."); Void MyResume () {Sustenflag = false; Experimente {Thread.sleep (1000); Thread One "); ob2.mysuspend (); System.out.println (" Suspendendo o Thread Two "); Thread.sleep (1000); ob2.myResume (); System.out.println (" Remumando o fio T wo ") ; T.Join (); }A saída deste programa é a mesma do programa anterior. Mais tarde neste livro, você verá mais exemplos de uso do mecanismo Java 2 para controlar os threads. Embora esse mecanismo não seja tão "limpo" quanto o método antigo, no entanto, é a maneira de garantir que nenhum erro ocorra em tempo de execução. É o método que todo o novo código deve levar.