A classe Java Thread também é uma classe de objeto e suas instâncias são herdadas do java.lang.Thread ou sua subclasse. Você pode criar um tópico em Java da seguinte maneira. A execução do thread pode chamar o método start () do thread:
Thread thread = new thread ();
thread.start ();
No exemplo acima, não escrevemos código de execução para o thread, então o thread termina após chamar o método.
Existem duas maneiras de escrever o código executado quando um thread é executado: um é criar uma instância da subclasse do encadeamento e substituir o método de execução, e o segundo é implementar a interface executável ao criar a classe. Em seguida, explicaremos estes dois métodos em detalhes:
Crie uma subclasse de thread
Crie uma instância da subclasse do encadeamento e substitua o método de execução. O método RUN será executado após chamar o método START (). O exemplo da subclasse de encadeamento acima pode ser criado e executado da seguinte maneira:
public classe mythread estende thread {public void run () {System.out.println ("mythread Running"); }} Mythread mythread = new mythread (); mytread.start ();Quando o thread começar, o método de início retornará imediatamente e não esperará até que o método de execução seja executado antes de retornar. É como se o método de execução fosse executado em outra CPU. Quando o método de execução for executado, o renúncia mythread da string será impresso.
Você também pode criar uma subclasse anônima do thread da seguinte maneira:
Thread Thread = new Thread () {public void run () {System.out.println ("Thread Running"); }}; thread.start ();Quando o método de execução do novo thread for executado, o computador imprimirá a string "Thread Running".
Implementando a interface executável
A segunda maneira de escrever o código de execução do encadeamento é criar uma nova instância da classe que implementa a interface java.lang.Runnable, e os métodos na instância podem ser chamados pelo thread. O seguinte é um exemplo:
public class MyRunnable implementa Runnable {public void run () {System.out.println ("MyRunnable Running"); }}Para que os threads executem o método run (), é necessário passar o objeto de instância do MyRunnable para o construtor da classe Thread. Exemplos são os seguintes:
Thread Thread = novo thread (new MyRunnable ());
thread.start ();
Quando o thread é executado, ele chama o método de execução que implementa a interface executável. "MyRunnable Running" será impresso no exemplo acima.
Da mesma forma, você pode criar uma classe anônima que implementa a interface executável, como mostrado abaixo:
Runnable myRunnable = new Runnable () {public void run () {System.out.println ("Runnable Running"); }} Thread thread = novo thread (myRunnable); thread.start ();Criar uma subclasse ou implementar uma interface executável?
Não há resposta definitiva para qual desses dois métodos é melhor e eles podem atender aos requisitos. Na minha opinião pessoal, prefiro implementar o método de interface executável. Como o pool de threads pode gerenciar efetivamente os threads que implementam a interface executável, se o pool de threads estiver cheio, novos threads farão fila para execução até que o pool de threads esteja ocioso. E se o thread for implementado implementando a subclasse do encadeamento, isso será um pouco mais complicado.
Às vezes, precisamos integrar as duas maneiras de implementar a interface executável e a subclasse de thread ao mesmo tempo. Por exemplo, uma instância que implementa uma subclasse de encadeamento pode executar vários threads que implementam a interface executável. Um aplicativo típico é o pool de threads.
Erro comum: chamando o método run () em vez do método start ()
Um erro comum cometido criando e executando um thread é chamar o método run () do thread em vez do método start (), como mostrado abaixo:
Thread newthread = novo thread (myRunnable ());
newthread.run (); // deve ser start ();
No começo, você não sente nada errado, porque o método run () é realmente chamado como você deseja. No entanto, de fato, o método run () não é executado pelo novo thread que acabou de ser criado, mas é executado pelo thread atual que criou o novo thread. Ou seja, é executado pelo encadeamento que executa as duas linhas de código acima. Para fazer com que o novo encadeamento criado execute o método run (), o método de início do novo thread deve ser chamado.
Nome do tópico
Ao criar um tópico, você pode dar um nome ao tópico. Isso nos ajuda a distinguir diferentes threads. Por exemplo: se vários threads forem gravados no System.out, podemos descobrir facilmente qual encadeamento está emitindo o nome do thread. Exemplos são os seguintes:
MyRunnable runnable = new myRunnable (); thread thread = new Thread (runnable, "novo thread"); thread.start (); system.out.println (thread.getName ());
Deve -se notar que, como o MyRunnable não é uma subclasse do thread, a classe Mirunnable não possui um método getName (). Você pode obter uma referência ao tópico atual das seguintes maneiras:
Thread.CurrentThread ();
String threadName = thread.currentThread (). GetName ();
Exemplo Código do tópico:
Aqui está um pequeno exemplo. Primeiro, saia o nome do encadeamento do método main (). Este tópico é alocado pela JVM. Em seguida, abra 10 fios e nomeie -os 1 ~ 10. Cada encadeamento sai após a saída de seu próprio nome.
classe pública threadExample {public static void main (string [] args) {System.out.println (thread.currentThread (). getName ()); para (int i = 0; i <10; i ++) {new Thread ("" + i) {public void run () {System.out.println ("Thread:" + getName () + "Running"); } }.começar(); }}}Deve -se notar que, embora a ordem de iniciar os threads seja ordenada, a ordem de execução não é ordenada. Ou seja, o thread 1 não é necessariamente o primeiro thread a produzir seu nome para o console. Isso ocorre porque os threads são executados em paralelo e não sequencialmente. A JVM e o sistema operacional determinam a ordem de execução dos threads, e a ordem de inicialização não é necessariamente a mesma que a dos threads.
O acima é uma compilação das informações criadas pelos threads java. Continuaremos a adicionar informações relevantes no futuro. Obrigado pelo seu apoio a este site!