Java Tutorial – Controle de Criação e Thread

Antes de inserir mais profundidades nos fios de execução, uma referência rápida da classe de linha é proposta.

Thread de classe

A classe está encapsula todo o controle necessário sobre os fios de execução (encadeamentos). Você tem que distinguir claramente um objeto de thread de um fio de execução ou fio. Essa distinção é complicada, embora possa ser simplificada se for considerada o objeto de thread como o painel de controle de um fio de execução (linha). A classe de rosca é a única maneira de controlar o comportamento dos encadeamentos e para essa finalidade é servido como métodos expostos nas seções a seguir.

Métodos de classe

Estes são os Métodos estáticos que devem ser chamados diretamente na classe de rosca.

CurrentThread ()

Este método retorna o objeto de thread que representa o fio de execução que está sendo executado no momento.

Rendimento ()

Este método faz com que o intérprete altere o contexto entre o fio atual e o próximo thread executável disponível. É uma maneira de garantir que gostamos de prioridade mais baixa não sofrem de fome.

sleep (longo)

o método de sono () faz com que o intérprete coloque o fio em andamento dormir durante o número de milissegundos indicados no parâmetro de invocação. Uma vez que os milissegundos tiverem decorrido, o referido tópico estará disponível novamente para a execução. Os relógios associados à maioria dos intérpretes Java não poderão obter maiores precisas de 10 milissegundos, desde que seja permitido indicar até que nanossegundos na chamada alternativa a este método.

métodos da instância

Todos os métodos da classe de rosca não são coletados aqui, mas apenas os mais interessantes, porque os outros correspondem a áreas onde o padrão Java não está completo, e pode permanecer obsoleto na próxima versão do JDK, portanto, se você deseja completar as informações que são definidas aqui, a documentação da interface de programação do aplicativo JDK (API) deve ser usada.

start ()

Este método indica o intérprete Java que cria Um contexto do tópico do sistema e começar a executá-lo. Em seguida, o método Executar () dessa linha será invocado no novo contexto do segmento. Você tem que ter cuidado para não ligar para o método Iniciar () mais de uma vez em um determinado tópico.

Executar ()

O método Executar () constitui o corpo de um thread execução. Este é o único método de interface runnable. É chamado pelo método Iniciar () após o encadeamento apropriado do sistema foi inicializado. Sempre que o método Executar () retornar o controle, o thread atual será interrompido.

stop ()

Este método faz com que o thread pare imediatamente. Muitas vezes, é uma maneira súbita de parar um segmento, especialmente se este método é executado no segmento em andamento. Nesse caso, a linha imediatamente após a chamada para o método STOP () nunca é executada, já que o contexto do thread morre antes da parada () retorna o controle. Uma maneira mais elegante de parar um tópico é usar alguma variável que faz com que o método Executar () termine de maneira ordenada. Na verdade, você nunca deve recorrer ao uso desse método.

Suspender ()

O método Suspend () é diferente de parar (). Suspender () Pegue o fio e faça com que sua execução pare sem destruir o sistema subjacente, nem o estado do fio anteriormente em execução. Se a execução de um fio estiver suspensa, ela pode ser chamada de resumo () no mesmo thread para conseguir que ela novamente funcione novamente.

resume ()

O método resume ( ) É usado para reviver um fio suspenso. Não há garantias de que a linha começa a ser executada imediatamente, uma vez que pode haver um tópico de alta prioridade atualmente, mas retoma () faz com que o fio seja um candidato a ser executado novamente.

setpriority (int)

O método setpriority () atribui a prioridade indicada pelo valor passado como parâmetro. Há algumas constantes predefinidas para a prioridade, definida na classe de rosca, como min_prioridade, norma_prioridade e max_priority, que tomam valores 1, 5 e 10, respectivamente. Como um guia aproximado de uso, ele pode ser estabelecido que a maioria dos processos de nível de usuário deve realizar uma prioridade em torno da NORM_PRIORIDADE. As tarefas de fundo, como uma entrada / saída para a rede ou o novo desenho da tela, devem ter uma prioridade próxima a min_prioridade. Com as tarefas para as quais a prioridade mais alta é definida, em torno de max_priority, você deve ser especialmente cuidadoso, porque se nenhuma chamada for feita para dormir () ou rendimento (), pode fazer com que o intérprete Java seja totalmente fora de controle.

getPriority ()

Este método retorna a prioridade do thread de execução em andamento, que é um valor entre um e dez.

setname (string)

Este método permite identificar o fio com um nome menmmônico. Desta forma, a purificação de programas multi-familiares é facilitada. O nome mnemônico aparecerá em todas as linhas de layout que são exibidas toda vez que o Java intérprete imprime exceções desconectadas.

getname ()

Este método retorna o valor atual, a corrente do tipo, atribuída Como um nome de segmento de execução usando setName ().

Criando um thread

Há duas maneiras de obter fios de execução (encadeamentos) em Java. Um está implementando a interface runnable, a outra é estender a classe de linha.

A implementação da interface runnable é a maneira usual de criar encadeamentos. As interfaces fornecem ao programador uma maneira de agrupar o trabalho de infraestrutura de uma classe. Eles são usados para projetar os requisitos comuns ao conjunto de classes a serem implementadas. A interface define trabalhos e classe ou classes, que implementam a interface para executar esse trabalho. Os diferentes grupos de classes que implementam a interface terão que seguir as mesmas regras de operação.

Existem algumas diferenças entre a interface e a classe, que já são conhecidas e aqui apenas são resumidas. Primeiro, uma interface só pode conter métodos abstratos e / ou variáveis estáticas e finais (constante). As aulas, por outro lado, podem implementar métodos e contêm variáveis que não são constantes. Em segundo lugar, uma interface não pode implementar nenhum método. Uma classe que implementou uma interface deve implementar todos os métodos definidos nessa interface. Uma interface tem a possibilidade de poder se espalhar de outras interfaces e, ao contrário das classes, ele pode ser estendido de várias interfaces. Além disso, uma interface não pode ser instanciada com o novo operador; Por exemplo, a seguinte instrução não é permitida:

Runnable a = new Runnable(); // No se permite

O primeiro método de criar um thread de execução é simplesmente para estender a classe de linha:

class MiThread extends Thread { public void run() { . . . }

O exemplo anterior cria uma nova classe mithread que estende a classe de rosca e sobrescreve o método thread.run () para sua própria implementação. O método Run () é onde todo o trabalho da classe será executado. Estendendo a classe de linha, você pode herdar os métodos e variáveis da classe pai. Nesse caso, só pode ser estendido ou derivado uma vez da classe pai. Esta limitação de java pode ser superada através da implementação de runnable:

Neste caso, precisamos criar uma instância de thread antes que o sistema possa executar o processo como um encadeamento . Além disso, o método Run () é definido na interface rangível e deve ser implementado. A única diferença entre os dois métodos é que este último é muito mais flexível. No exemplo anterior, ainda há a oportunidade de estender a classe mithread, se necessário. A maioria das classes criadas que precisam ser executadas como um thread implementará a interface rangível, pois provavelmente estenderão qualquer funcionalidade para outras classes.

Não pense que a interface runnable está fazendo algo quando a tarefa progresso. Ele contém apenas métodos abstratos, com os quais é uma classe para dar uma ideia sobre o design da classe de discussão. Na verdade, se as fontes Java forem observadas, ele pode ser verificado que ele contém apenas um método abstrato:

package java.lang;public interface Runnable { public abstract void run() ; }

e isso é tudo que existe na interface Runnable. Como visto, uma interface só fornece um design para classes que serão implementadas. No caso de runnable, forçar a definição do método Run (), portanto, a maior parte do trabalho é feita na aula de discussão. Um olhar um pouco mais profundo para a definição da classe de thread dá idéia do que realmente está acontecendo:

public class Thread implements Runnable { ... public void run() { if( tarea != null ) tarea.run() ; } } ... }

deste código é claro que a classe de thread também Implemente a interface runnable. Tarefa. Quando isso acontece, o método Executar () da classe fará com que ele seja executado como um tópico.

Um exemplo é apresentado, java1001.java, que implementa a interface runnable para criar um programa multi-telefone.

class java1001 { static public void main( String args ) { // Se instancian dos nuevos objetos Thread Thread hiloA = new Thread( new MiHilo(),"hiloA" ); Thread hiloB = new Thread( new MiHilo(),"hiloB" ); // Se arrancan los dos hilos, para que comiencen su ejecución hiloA.start(); hiloB.start(); // Aquí se retrasa la ejecución un segundo y se captura la // posible excepción que genera el método, aunque no se hace // nada en el caso de que se produzca try { Thread.currentThread().sleep( 1000 ); }catch( InterruptedException e ){} // Presenta información acerca del Thread o hilo principal // del programa System.out.println( Thread.currentThread() ); // Se detiene la ejecución de los dos hilos hiloA.stop(); hiloB.stop(); } }class NoHaceNada {// Esta clase existe solamente para que sea heredada por la clase// MiHilo, para evitar que esta clase sea capaz de heredar la clase// Thread, y se pueda implementar el interfaz Runnable en su// lugar}class MiHilo extends NoHaceNada implements Runnable { public void run() { // Presenta en pantalla información sobre este hilo en particular System.out.println( Thread.currentThread() ); } }

Como você pode ver, o programa define uma classe Mihilo que se estende para a classe não atacada e implementa a interface rangível. O método Executar () é redefinido na classe Mihil para apresentar informações sobre o encadeamento.

O único motivo para estender a classe incomparável é fornecer um exemplo de uma situação em que alguma outra classe tem que ser estendida , além de implementar a interface.

no exemplo Java1002.Java mostra o mesmo programa basicamente, mas, nesse caso, estendendo a classe de discussão, em vez de implementar a interface runnable para criar o programa multi-telefone.

class java1002 { static public void main( String args ) { // Se instancian dos nuevos objetos Thread Thread hiloA = new Thread( new MiHilo(),"hiloA" ); Thread hiloB = new Thread( new MiHilo(),"hiloB" ); // Se arrancan los dos hilos, para que comiencen su ejecución hiloA.start(); hiloB.start(); // Aquí se retrasa la ejecución un segundo y se captura la // posible excepción que genera el método, aunque no se hace // nada en el caso de que se produzca try { Thread.currentThread().sleep( 1000 ); }catch( InterruptedException e ){} // Presenta información acerca del Thread o hilo principal // del programa System.out.println( Thread.currentThread() ); // Se detiene la ejecución de los dos hilos hiloA.stop(); hiloB.stop(); } }class MiHilo extends Thread { public void run() { // Presenta en pantalla información sobre este hilo en particular System.out.println( Thread.currentThread() ); } }

em Esse caso, a nova classe Mihil estende a classe de tópicos e não implementa a interface rangível diretamente (a classe de rosca implementa a interface rangível, portanto, a Mihilo indiretamente também está implementando essa interface). O restante do programa é semelhante ao anterior.

e você ainda pode apresentar um exemplo mais simples, usando um fabricante da classe de discussão que não precisa de parâmetros, conforme apresentado no exemplo java1003.java. Nos exemplos acima, o construtor usado para encadeamento necessário dois parâmetros, o primeiro objeto de qualquer tipo que implementa a interface em execução e a segunda string indicada pelo nome do encadeamento (esse nome é independente do nome da variável que se refere a o objeto de thread).

class java1003 { static public void main( String args ) { // Se instancian dos nuevos objetos Thread Thread hiloA = new MiHilo(); Thread hiloB = new MiHilo(); // Se arrancan los dos hilos, para que comiencen su ejecución hiloA.start(); hiloB.start(); // Aquí se retrasa la ejecución un segundo y se captura la // posible excepción que genera el método, aunque no se hace // nada en el caso de que se produzca try { Thread.currentThread().sleep( 1000 ); }catch( InterruptedException e ){} // Presenta información acerca del Thread o hilo principal // del programa System.out.println( Thread.currentThread() ); // Se detiene la ejecución de los dos hilos hiloA.stop(); hiloB.stop(); } }class MiHilo extends Thread { public void run() { // Presenta en pantalla información sobre este hilo en particular System.out.println( Thread.currentThread() ); } }

Sudgents neste exemplo para instanciar objetos de rosca, são muito menos complexos, sendo o programa, em essência, o mesmo dos exemplos Anterior.

Iniciando um thread

Aplicativos Executar principal () após o início. Esta é a razão pela qual o principal () é o lugar natural para criar e começar outros tópicos. A linha do código:

 t1 = new TestTh( "Thread 1",(int)(Math.random()*2000) );

Crie um novo fio de execução. Os dois argumentos passados representam o nome do tópico e o tempo que você deseja esperar antes de imprimir a mensagem.

Quando tiver controle direto sobre os encadeamentos, você tem que iniciá-los explicitamente. No exemplo com:

 t1.start();

Iniciar (), é na verdade um método oculto no fio de execução que chama de execução ().

Manipulação de uma linha

Se tudo correu bem na criação do encadeamento, o T1 deve conter um fio válido, que nós controlaremos no método Executar ().

uma vez dentro Executar (), as declarações de execução podem ser iniciadas como em outros programas. Executar () serve como uma rotina principal () para encadeamentos; Quando correr () termina, ele também faz o fio. Tudo o que você deseja fazer o thread de execução deve estar dentro da execução (), então quando é dito que um método está sendo executado, é obrigatório escrever um método de execução ().

Neste exemplo, tentamos Para esperar imediatamente por uma quantidade aleatória de tempo (passada pelo construtor):

sleep( retardo );

O método de sono () simplesmente informa ao sono de encadeamento de execução durante os milissegundos especificados . O sono () deve ser usado quando destinado a atrasar a execução do segmento. O sono () não consome recursos do sistema enquanto o encadeamento dorme. Desta forma, outros tópicos podem continuar funcionando. Uma vez que o atraso foi feito, a mensagem é impressa “Hello World!” Com o nome do segmento e o atraso.

Suspensão de um thread

pode ser útil para suspender a execução de um thread sem marcar um limite de tempo. Se, por exemplo, é construir um applet com um thread de animação, certamente você vai querer permitir que o usuário a opção interrompa a animação até que eu queira continuar. Não se trata de terminar a animação, mas desativá-la. Para este tipo de controle de fio de execução, você pode usar o método suspendente ().

 t1.suspend();

Este método não interrompe a execução permanentemente. O encadeamento é suspenso indefinidamente e para reativá-lo novamente, é necessário ser invocado para o método resumido ():

 t1.resume();

Pare um thread

O último elemento de controle que é necessário nos fios de execução é o método STOP (). É usado para terminar a suspensão de um tópico:

 t1.stop();

Esta chamada não destrói o segmento, mas interrompe sua execução. A execução não pode ser retomada com T1.Start (). Quando as variáveis que são usadas no encadeamento são não atribuídas, o objeto Thread (criado com novo) será marcado para removê-lo e o coletor de lixo será responsável por liberar a memória usada.

no exemplo , Eu não sei que você precisa explicitamente parar o tópico de execução. É simplesmente deixar você terminar. Os programas mais complexos precisarão de controle sobre cada um dos encadeamentos de lances, o método STOP () podem ser usados nessas situações.

Se necessário, ele pode ser verificado se um encadeamento estiver vivo ou não; Considerando viva um tópico que começou e não foi preso.

 t1.isAlive();

Este método retornará TRUE caso o thread T1 esteja vivo, isto é, já foi chamado de seu método de execução () e não parou com uma parada () ou terminou o método Executar () em sua execução.

No exemplo, não há problemas para fazer uma parada incondicional, quando todos os encadeamentos ao vivo são. Mas se em um fio de execução, você pode não estar vivo, o método STOP () é invocado, uma exceção será gerada.Neste caso, no qual o estado do fio não pode ser conhecido antecipadamente é onde é necessário o uso do método isalive ().

Leave a Comment

O seu endereço de email não será publicado. Campos obrigatórios marcados com *