Existem duas maneiras de criar threads em Java: usando a classe Thread e usando a interface Runnable. Ao usar a interface Runnable, você precisa criar uma instância Thread. Portanto, quer você crie um thread por meio da classe Thread ou da interface Runnable, você deve criar uma instância da classe Thread ou de sua subclasse. O construtor da classe Thread foi sobrecarregado oito vezes. O construtor é o seguinte:
Copie o código do código da seguinte forma:
Tópico público();
thread público (alvo executável);
Thread público (nome da string);
thread público (destino executável, nome da string);
public Thread (grupo ThreadGroup, destino executável);
public Thread (grupo ThreadGroup, nome da string);
public Thread (grupo ThreadGroup, destino executável, nome da string);
public Thread (grupo ThreadGroup, destino executável, nome da string, stackSize longo);
Alvo executável
Uma instância de uma classe que implementa a interface Runnable. Deve-se observar que a classe Thread também implementa a interface Runnable, portanto, instâncias de classes herdadas da classe Thread também podem ser passadas para este construtor como alvos.
Nome da sequência
O nome do tópico. Este nome pode ser definido através do método setName da classe Thread após a criação de uma instância Thread. Se o nome do thread não estiver definido, o thread usará o nome do thread padrão: Thread-N é a ordem na qual o thread é criado e é um número inteiro positivo não repetido.
Grupo ThreadGroup
O grupo de threads ao qual pertence o thread criado atualmente. Se nenhum grupo de encadeamentos for especificado, todos os encadeamentos serão adicionados a um grupo de encadeamentos padrão. Detalhes sobre grupos de threads serão discutidos em detalhes em capítulos posteriores.
pilha longaSize
O tamanho da pilha de threads Esse valor geralmente é um múltiplo inteiro da página da CPU. Por exemplo, o tamanho da página x86 é 4 KB. Na plataforma x86, o tamanho padrão da pilha de threads é 12 KB.
Uma classe Java comum pode se tornar uma classe thread, desde que herde da classe Thread. E o código do thread pode ser executado através do método start da classe Thread. Embora as subclasses da classe Thread possam ser instanciadas diretamente, o método run da classe Thread deve ser substituído na subclasse para realmente executar o código do thread. O código a seguir fornece um exemplo de uso da classe Thread para criar um thread:
Copie o código do código da seguinte forma:
pacote mitoread;
classe pública Thread1 estende Thread
{
execução de vazio público ()
{
System.out.println(this.getName());
}
público estático void principal(String[] args)
{
System.out.println(Thread.currentThread().getName());
Tópico1 Tópico1 = novo Tópico1();
Tópico1 Tópico2 = novo Tópico1();
thread1.start();
thread2.start();
}
}
O código acima cria dois threads: thread1 e thread2. As linhas 005 a 005 no código acima são o método run da classe Thread1. Quando o método start é chamado nas linhas 014 e 015, o sistema chama automaticamente o método run. Na linha 007, this.getName() é usado para gerar o nome do thread atual. Como o nome do thread não é especificado quando o thread é criado, a saída do nome do thread é o valor padrão do sistema, que está na forma de Thread. -n. O nome do thread principal é exibido na linha 011.
Os resultados da execução do código acima são os seguintes:
principal
Tópico-0
Tópico-1
Como pode ser visto na saída acima, a saída principal na primeira linha é o nome do thread principal. Os seguintes Thread-1 e Thread-2 são os resultados de saída de thread1 e thread2 respectivamente.
Nota: Qualquer programa Java deve ter um thread principal. Geralmente, o nome deste thread principal é main. Somente criando threads adicionais no programa ele pode ser considerado um verdadeiro programa multithread. Em outras palavras, um programa multithread deve ter mais de um thread.
A classe Thread possui um construtor sobrecarregado para definir o nome do thread. Além de usar o método construtor para definir o nome do thread ao criar um thread, você também pode usar o método setName da classe Thread para modificar o nome do thread. Para definir o nome do thread por meio do construtor da classe Thread, você deve usar o construtor público Thread(String name) da classe Thread na subclasse Thread. Portanto, você também deve adicionar um thread para passar no construtor Thread Name. . O código a seguir fornece um exemplo de configuração do nome do thread:
Copie o código do código da seguinte forma:
pacote mitoread;
classe pública Thread2 estende Thread
{
String privada quem;
execução de vazio público ()
{
System.out.println(who + ":" + this.getName());
}
público Thread2(String quem)
{
super();
isto.quem = quem;
}
public Thread2 (String quem, String nome)
{
super(nome);
isto.quem = quem;
}
público estático void principal(String[] args)
{
Thread2 thread1 = new Thread2 ("thread1", "MyThread1");
Thread2 thread2 = novo Thread2 ("thread2");
Tópico2 Tópico3 = novo Tópico2 ("thread3");
thread2.setName("MeuThread2");
thread1.start();
thread2.start();
thread3.start();
}
Existem dois construtores na classe:
Linha 011: amostra pública2_2(String quem)
Este construtor possui um parâmetro: who. Este parâmetro é usado para identificar o thread criado atualmente. O construtor padrão do Thread, public Thread(), ainda é chamado neste construtor.
Linha 016: public sample2_2(String quem, String nome)
O who neste construtor tem o mesmo significado que o who no primeiro construtor, e o parâmetro name é o nome do thread. Neste construtor, é chamado o construtor público Thread(String name) da classe Thread, que é super(name) na linha 018.
Três threads são estabelecidos no método principal: thread1, thread2 e thread3. Entre eles, thread1 define o nome do thread por meio do método de construção, thread2 modifica o nome do thread por meio do método setName e thread3 não define o nome do thread.
Os resultados da execução são os seguintes:
Copie o código do código da seguinte forma:
thread1:MeuThread1
thread2:MeuThread2
tópico3:Tópico-1
Como pode ser visto na saída acima, os nomes dos threads thread1 e thread2 foram modificados, enquanto o nome do thread thread3 ainda é o valor padrão: Thread-1. A razão pela qual o nome do thread de thread3 não é Thread-2, mas Thread-1 é porque o nome de thread2 foi especificado na linha 026. Portanto, quando thread3 é iniciado, o nome do thread de thread3 é definido como Thread-1. Então você obterá a saída acima.
Nota: Você pode usar setName para definir o nome do thread antes e depois de chamar o método start. No entanto, usar setName para modificar o nome do thread após chamar o método start causará incerteza, o que significa que setName não pode ser executado até que o método run seja. executado. Se você quiser usar o nome do thread no método run, ocorrerá um fenômeno que, embora o método setName seja chamado, o nome do thread não será modificado.
O método start da classe Thread não pode ser chamado várias vezes. Por exemplo, o método thread1.start() não pode ser chamado duas vezes. Caso contrário, uma IllegalThreadStateException será lançada.