Este artigo é um resumo do uso básico do Java Multithreading.
Este artigo explicará o uso básico do Java Multithreading dos seguintes aspectos:
Como usar o Multithreading
Duas maneiras de começar um tópico
O Java fornece duas maneiras de usar multi-threading. Uma é escrever uma classe para herdar thread, substituir o método de execução e, em seguida, chamar o método Iniciar para iniciar o thread. Neste momento, essa classe executará o código no método de execução da maneira como outro thread. Outra maneira é gravar uma classe para implementar a interface executável, implementar o método da interface executar e, em seguida, criar um objeto Thread, usar a classe que implementa a interface executável como um parâmetro de construção, passa -o para o objeto Thread e, finalmente, o objeto Thread chama o método de início.
O método de início aqui é um método com função de inicialização, que chama internamente o método de execução. Portanto, somente quando o método de início for chamado será iniciado outro tópico, o método de execução será chamado diretamente ou será executado no mesmo tópico, em vez de executar em outro tópico
Além disso, o método de início apenas informa à máquina virtual que o thread pode ser iniciado, o que significa que o thread está no estado pronto, mas não significa que a chamada para iniciar será executada imediatamente. Isso exige que a espera da JVM decida quando executar o thread. Em outras palavras, se houver dois threads A e B, as chamadas começam primeiro e B liga para começar mais tarde, isso não significa que o thread a execute primeiro e o Thread B é executado posteriormente. Tudo isso é determinado pela JVM e pode ser considerado uma inicialização aleatória.
Abaixo, usamos o código real para ilustrar duas maneiras de iniciar threads:
O primeiro tipo é o tópico herdador
classe pública ExampleThread estende o thread {@Override public void run () {super.run (); System.out.println ("Este é um ExampleThread herdado do thread"); }}O código de teste pode ser encontrado na classe ExampleThreadTest no diretório de teste
Outra maneira, implementa a interface executável
classe pública Examplerunable implementa runnable {public void run () {System.out.println ("Esta é a classe que implementa a interface executável"); }}Para o código de teste, você pode ver a classe ExamplerunableTest no diretório de teste.
Como obter algumas informações sobre o multithreading
Depois de iniciar o multi-thread, esperamos obter algumas informações sobre o thread iniciado por meio de algumas APIs. O JDK nos fornece um método de classe de thread para obter algumas informações sobre o thread.
Obtenha o nome do tópico
Esses métodos são métodos internos de encadeamento, para que possamos chamar esses métodos de duas maneiras. Uma é que, quando nossa classe herda o thread para usar o multi-thread, podemos usar isso para chamá-lo. Outra maneira é chamar esses métodos através do Thread.CurrentThread (). No entanto, esses dois métodos são diferentes em diferentes cenários de uso.
Vamos analisar brevemente o uso de dois métodos.
O primeiro thread.currentThread () é usado, o código é o seguinte:
classe pública ExamplCurrentThread estende o thread {public ExamplCurrentThread () {System.out.println ("Impressão do método do construtor:" + Thread.currentThread (). getName ()); } @Override public void run () {super.run (); System.out.println ("Impressão do método de execução:" + Thread.currentThread (). GetName ()); }}O código de teste é o seguinte:
classe pública ExamplCurrentThreadTest estende o teste {public void testInit () lança exceção {ExamplCurrentThread thread = new ExamplCurrentThread (); } public void testRun () lança Exceção {ExamplCurrentThread thread = new ExamplCurrentThread (); thread.start (); Thread.sleep (1000); }}Os resultados são os seguintes:
Impressão do método do construtor: impressão do método mainrun: impressão do método de construção Thread-0: Principal
Por que usamos o thread.currentThread () interno ExampleRentThread para exibir que o método de construção é impresso como principal, porque thread.currentThread () retorna as informações de que o segmento de código está sendo chamado por esse thread. É óbvio que o método de construção é executado pelo encadeamento principal e o método de execução é executado pelo thread que iniciamos por nós mesmos. Como não é nomeado, é o Thread-0 padrão.
Em seguida, estamos dando uma olhada em herdar do thread e chamá -lo com isso.
classe pública ComplexCurrentThread estende o thread {public complexCurrentThread () {System.out.println ("Begin =========="); System.out.println ("thread.currentThread (). GetName =" + thread.currentThread (). GetName ()); System.out.println ("this.getName () =" + this.getName ()); System.out.println ("end ==========="); } @Override public void run () {super.run (); System.out.println ("Run Begin ==========="); System.out.println ("thread.currentThread (). GetName =" + thread.currentThread (). GetName ()); System.out.println ("this.getName () =" + this.getName ()); System.out.println ("Run End =================="); }}O código de teste é o seguinte:
classe pública ComplexCurrentThreadTest estende o teste {public void testRun () lança exceção {complexCurrentThread thread = new ComplexCurrentThread (); Thread.setName ("Byhieg"); thread.start (); Thread.sleep (3000); }}Os resultados são os seguintes:
BEGIN =========== Thread.CurrentThread ().
Primeiro de tudo, ao criar o objeto, o construtor ainda é executado pelo encadeamento principal, então Thread.currentThread () obtém o nome do encadeamento principal, mas esse método se refere ao objeto que chama o método, ou seja, as informações do encadeamento do complexoCurrentThread. Ainda não há nome do set, por isso é o nome padrão. Então o método de execução é thread.currentThread () ou isso retorna informações do thread com o conjunto de nomes Byhieg.
SO Thread.CurrentThread refere -se às informações do thread que executam especificamente este bloco de código. O construtor é executado pelo Main, e o método de execução é qual encadeamento é iniciado e qual thread é executado. Desse ponto de vista, as informações que isso podem obter são imprecisas, porque se executarmos isso.getName () em execução, mas o método de execução será iniciado por outro thread, não podemos obter as informações da nova cidade executando o método de execução por meio desse nome. E apenas as classes que herdam o encadeamento podem ter métodos como o GetName, que é um desastre para os idiomas de recursos de Java que não possuem várias heranças. Para todas as informações sobre os threads que queremos obter depois, usamos thread.currentThread () para chamar a API.
Obtenha o ID do tópico
Ligue para GetId para obter a identificação exclusiva do thread. É o mesmo que o uso do GetName acima. Não há nada a dizer. Você pode procurar diretamente o ExementIdThread e sua classe de teste ExementIDHREADTEST.
Determine se o tópico sobrevive
A função do método isalive () é testar se o thread está ativo. O chamado estado ativo significa que o encadeamento foi iniciado, mas não terminou. Ou seja, após o início do fio, é considerado vivo.
Vamos dar uma olhada em exemplos específicos:
classe pública Alivethread estende o thread {@Override public void run () {super.run (); System.out.println ("Está vivo no método de execução" + "" + thread.currentThread (). Isalive ()); }}O método de teste é o seguinte:
classe pública alivethreadtest estende o teste {public void testRun () lança exceção {alivethread thread = new alivethread (); System.out.println ("BEGIN ==" + Thread.isalive ()); thread.start (); Thread.sleep (1000); System.out.println ("end ==" + thread.isalive ()); Thread.sleep (3000); }}Os resultados são os seguintes:
BEGN == se TrueEnd no método falso == FALSE
Podemos descobrir que, antes do início, o tópico é considerado sem surpresa e, quando corre, está vivo. Quando o método de execução é executado, ele é considerado sem surpresa.
Como parar um tópico
Determinar se o tópico terminou
O JDK fornece alguns métodos para determinar se o thread é encerrado - ISInterrupted () e interrompido ()
Como parar tópicos
Este é um método mais importante para obter informações sobre threads, porque está relacionado ao método de encerramento de threads. Deixe -me falar primeiro sobre várias maneiras de encerrar os threads:
Não vou falar sobre o primeiro, o método da segunda parada () foi abandonado porque os seguintes motivos podem ocorrer:
Para exemplos específicos, você pode ver StoplockThread e sua classe de teste StopLockThreadtest
O terceiro tipo é o método de terminação atualmente recomendado, chamando de interrupção e, em seguida, determinando se deve terminar no método de execução. Existem duas maneiras de julgar a rescisão. Um é o método estático interrompido () da classe Thread, e o outro é o método do membro do thread é interrupto (). Há uma diferença entre esses dois métodos. O primeiro método redefinirá automaticamente o estado. Se interrompido () for chamado duas vezes seguidas, se for falso na primeira vez, a segunda vez deve ser verdadeira. E ISInterrupted () não.
Exemplos são os seguintes:
classe pública Exemplo de interrupção, estende o thread {@Override public void run () {super.run (); tente {for (int i = 0; i <50000000; i ++) {if (interrupted ()) {System.out.println ("já é um estado de parada, eu quero sair"); lançar novas interrupções interrompedException ("Stop ......"); } System.out.println ("i =" + (i + 1)); }} catch (interruptEdException e) {System.out.println ("Pare suavemente"); }}}O código de teste é o seguinte:
classe pública ExementInterRruptThreadTest estende o teste {public void testRun () lança exceção {ExempliEInterrupthread thread = new ExempliEInterruptThread (); thread.start (); Thread.sleep (1000); thread.Interrupt (); }}O quarto método é o mesmo que o terceiro. A única diferença é substituir a exceção jogada no código acima pelo retorno. Eu ainda gosto de jogar exceções. Existem muitas formas de processamento aqui, como imprimir informações, fechar ou capturar o recurso e depois jogá -las na camada superior novamente.
Observe que a exceção que jogamos acima é uma interrupção. Aqui falamos brevemente sobre as razões pelas quais essa exceção pode ser gerada. No caso do sono original do thread, ligue para encerrar o encadeamento ou encerrar o encadeamento primeiro e depois deixe o thread dormir.
Como pausar o tópico
Os dois métodos a seguir são fornecidos no JDK para pausar threads e restaurar threads.
Esses dois métodos são métodos abandonados, como o método de parada, e seu uso é o mesmo que parada, suspendendo brutalmente os threads e restaurando threads. As principais razões pelas quais esses dois métodos são abandonados são:
Alguns outros usos de tópicos
Alguns outros usos básicos dos tópicos são os seguintes:
Concessões de thread
O JDK fornece o método de rendimento () para fazer o thread desistir do recurso atual da CPU e fornecer a outras tarefas para ocupar o tempo da CPU, mas isso também é uma coisa aleatória. É possível que ele ocupe a fatia de tempo logo após desistir dos recursos.
Para exemplos específicos, não
Defina a prioridade dos threads
Podemos definir a prioridade dos threads para permitir que a CPU o máximo possível envie os recursos de execução para threads com maior prioridade. Java define 1-10 10 níveis de prioridade, e existem três variáveis estáticas para fornecer três níveis de prioridade:
/*** A prioridade mínima que um encadeamento pode ter. */ public final static int min_priority = 1; /*** A prioridade padrão atribuída a um thread. */ public final static int norm_priority = 5; /*** A prioridade máxima que um thread pode ter. */ public final static int max_priority = 10;
Podemos definir a prioridade do thread através do SetPriority e podemos passar diretamente em três variáveis estáticas para o recurso ou passar diretamente nos números 1-10. Após a definição, o tópico terá prioridades diferentes. O que acontece se não definirmos prioridade?
A prioridade dos threads é herdada. Se iniciarmos o encadeamento B no thread A, AB tem a mesma prioridade. Geralmente, quando iniciamos um thread no thread principal, temos prioridade consistente com o thread principal. A prioridade do encadeamento principal é 5 por padrão.
Aqui estão algumas regras para prioridade:
Guarda de thread
O JDK fornece um método setDaemon para definir um thread para se tornar um thread Daemon. A característica dos threads Daemon é que, depois que outros threads não daemon são executados, os threads Daemon serão destruídos automaticamente. Um exemplo típico é o GC Recycler.
Para detalhes, você pode ver ExampledaemoThread e ExampledaemoMeadTest.
Resumir
Este artigo resume principalmente alguns usos básicos dos threads java e está incluído no segundo artigo sobre segurança e sincronização de threads.
O exposto acima é todo o conteúdo deste artigo. Espero que o conteúdo deste artigo seja de ajuda para estudar ou trabalhar de todos. Eu também espero apoiar mais wulin.com!