Tópicos de criação Java (interface executável e classe de threads)
Na maioria dos casos, um thread é criado instantando um objeto de thread. Java define duas maneiras:
O seguinte descreve cada método por sua vez.
Implementando a interface executável
A maneira mais fácil de criar um thread é criar uma classe que implementa a interface executável. Runnable Abstracts Uma unidade de execução de código. Você pode criar threads para cada objeto implementando a interface executável. Para implementar a interface Runnable, uma classe só precisa implementar um método simples de run (), que é declarado da seguinte maneira:
public void run ()
Em Run (), você pode definir o código para criar novos threads. É crucial entender o seguinte: o método run () pode chamar outros métodos, consultar outras classes e declarar variáveis como o thread principal. A única diferença é que o Run () estabelece outra entrada simultânea de execução de threads no programa. Quando executado () retorna, o thread termina.
Depois de criar uma classe que implementa a interface executável, você precisa instanciar um objeto da classe Thread dentro da classe. A classe Thread define vários construtores. O que vamos usar é o seguinte:
Thread (Runnable Threadob, String ThreadName)
Neste construtor, o Threadob é uma instância que implementa a classe de interface executável. Isso define o ponto de partida para a execução do encadeamento. O nome do novo thread é definido pelo ThreadName.
Depois que um novo thread é criado, ele não é executado até que o método Start () seja chamado, que é definido na classe Thread. Essencialmente, start () executa uma chamada para executar (). O método start () é declarado da seguinte maneira:
Void Start ()
O exemplo a seguir é criar um novo thread e iniciá -lo em execução:
// Crie um segundo thread.class Newthread implementa Runnable {Thread T; : " + t); t.start (); // iniciar o thread} // Este é o ponto de entrada para o segundo thread. public void run () {try {for (int i = 5; i> 0; i -) {System.out.println ("thread Child:" I); OUT .Println ("Thread Thread."); 0; ); No construtor Newthread, o novo objeto Thread é criado pela seguinte declaração:
t = novo thread (este, "Demo Thread");
Isso indica que, nesse objeto, você deseja que o novo thread chamar o método run (). Em seguida, Start () é chamado e a execução do thread é iniciada com o método run (). Isso faz com que o thread infantil para o loop inicie a execução. Depois de ligar para Start (), o Newthread Constructor retorna para Main (). Quando o fio principal é restaurado, ele atinge o loop for. Os dois threads continuam a correr, compartilhando a CPU até que o loop termine. A saída deste programa é a seguinte:
Tópico infantil: Tópico [Demo thread, 5, principal] Tópico principal: 5Child Thread: 5Child Thread: 4Main Thread: 4Child Thread: 3Child Thread: 2Main Thread: 3Child Thread: 1e Xiting Child Thread.Main Thread: 2Main Thread: 1Main Thread saindo .
Como mencionado anteriormente, em um programa multithread, o thread principal geralmente deve ser o último thread que termina em execução. De fato, para alguns JVMs antigos, se o thread principal terminar antes do tópico infantil, o sistema de tempo de execução do Java poderá "pendurar". O programa acima mencionado garante que o thread principal termine no final, porque o encadeamento principal dorme por 1000 milissegundos, enquanto o thread infantil é de apenas 500 milissegundos. Isso faz com que o fio infantil termine antes que o encadeamento principal termine. Em suma, você verá uma maneira melhor de esperar o tópico terminar.
Thread estendido
Outra maneira de criar um encadeamento é criar uma nova classe que estende a classe Thread e depois cria uma instância dessa classe. Quando uma classe herda o encadeamento, ele deve sobrecarregar o método run (), que é a entrada para o novo thread. Ele também precisa chamar o método START () para iniciar a nova execução do thread. O seguinte é reescrever o programa anterior com a classe de threads estendida:
// Crie um segundo thread, estendendo o ThreadClass Newthread estende o thread {newthread () {// Crie um novo thread super ("Demo thread"); (); ("Thread Child:" I); ");}} classe ExtendThread {public static void main (string args []) {new newthread (); // crie um novo thread Try {for (int i = 5; i> 0; i-) {System. OUT ::::::::::::::: .Println ("Tópico principal:" + i); Tópico principal interrompido. ");} System.ou t.println (" Tópico principal saindo. ");}} Este programa gera a mesma saída da versão anterior. O encadeamento infantil é gerado pelo objeto Newthread instanciado, derivado da classe Thread. Observe a chamada para super () em Newthread. Este método chama o construtor de threads do seguinte formulário:
Tópico público (string threadName)
Aqui, ThreadName especifica o nome do thread.
Escolha o método certo
Neste ponto, você definitivamente se perguntará por que Java tem duas maneiras de criar tópicos infantis, o que é melhor. Todas as perguntas são atribuídas a um ponto. A classe Thread define uma variedade de métodos que podem ser sobrecarregados por classes derivadas. Para todos os métodos, a única coisa que deve ser sobrecarregada é o método run (). É claro que esse é o mesmo método necessário para implementar a interface executável. Muitos programadores de Java acreditam que as classes devem ser estendidas apenas quando forem fortalecidas ou modificadas. Portanto, se você não sobrecarregar outros métodos de thread, é melhor implementar apenas a interface executável. Claro que cabe a você decidir. No entanto, em outras partes deste capítulo, aplicamos classes que implementam a interface executável para criar threads.