Este artigo segue o artigo anterior "Explicação detalhada dos exemplos Java Multithreading (i)".
4. O estado de bloqueio e controle de roscas dos multithreads Java
Vários tipos específicos de bloqueio de Java foram mencionados acima. Vamos dar uma olhada nos principais métodos que causam bloqueio de thread Java.
1.Join ()
Junte -se - deixe um thread aguardar que outro tópico seja concluído antes de continuar a execução. Se o thread A for chamado no método de junção do Thread B () no corpo de execução do encadeamento, o thread a será bloqueado e somente depois que o Thread B é conhecido por ter concluído a execução do Thread B, a pode continuar a executar.
classe pública threadtest {public static void main (string [] args) {myRunnable myRunnable = new MyRunnable (); Thread Thread = novo thread (myRunnable); for (int i = 0; i <100; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i == 30) {thread.start (); tente {thread.join (); // O encadeamento principal precisa aguardar a execução do encadeamento antes de continuar executando} catch (interruptedException e) {e.printStackTrace (); }}}}}}}}}}}}}}}}}}}}}}}}}2.Sleep ()
Sono - Deixe o tópico de execução atualmente pausar o tempo especificado e entrar em um estado de bloqueio. Durante o período em que dorme, o tópico não terá a oportunidade de executar porque não está no estado pronto. Mesmo se não houver outros threads executáveis no sistema neste momento, os threads no sono () não serão executados. Portanto, o método Sleep () é frequentemente usado para pausar a execução do encadeamento.
Como mencionado anteriormente, quando o método start () do thread recém -criado é chamado, o thread entra no estado pronto e pode obter a fatia de tempo da CPU em algum momento para executar. Se você deseja que o novo thread seja executado imediatamente com certa necessidade, basta chamar o sono (1) do thread original diretamente.
classe pública threadtest {public static void main (string [] args) {myRunnable myRunnable = new MyRunnable (); Thread Thread = novo thread (myRunnable); for (int i = 0; i <100; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i == 30) {thread.start (); tente {thread.sleep (1); // Terre -se que seja executado imediatamente} Catch (interruptedException e) {e.printStackTrace (); }}}}}}}}}}}}}}}}}}}}}}}}}Nota: Dormir por um milissegundo é suficiente, porque a CPU não ficará ociosa e mudará para o thread recém -criado.
3. Tópico de fundo (Thread Daemon)
Conceito/Objetivo: Os threads de fundo fornecem principalmente serviços a outros threads (relativamente chamados de threads de primeiro plano) ou "threads Daemon". Como o tópico de coleta de lixo na JVM.
Ciclo de vida: o ciclo de vida de um tópico de fundo está relacionado ao ciclo de vida do fio de primeiro plano. Ele é refletido principalmente em: quando todos os threads de primeiro plano entram no estado morto, o thread de fundo morre automaticamente (na verdade, isso é fácil de entender, porque o objetivo do thread de fundo é servir o fio de primeiro plano. Como todos os threads de primeiro plano morreram, qual é o uso dele ainda o mantém ... ótimo!).
Definir encadeamento de fundo: chamando o método setDaemon (true) do objeto Thread pode definir o thread especificado como um encadeamento em segundo plano.
classe pública threadtest {public static void main (string [] args) {thread mythread = new mythread (); for (int i = 0; i <100; i ++) {System.out.println ("Thread Indication i ="+i); if (i == 20) {mythread.setDaemon (true); mythread.start (); }}}}} classe mythread estende thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("i ="+i); tente {thread.sleep (1); } catch (interruptedException e) {// TODO BLOCO DE CATCH AUTOGERATIDO E.PRINTSTACKTRACE (); }}}}Determine se o thread é um encadeamento em segundo plano: ligue para o método iSDeamon () do objeto Thread.
NOTA: O encadeamento principal é o encadeamento de primeiro plano por padrão, o encadeamento infantil criado na criação do encadeamento em primeiro plano é o encadeamento de primeiro plano por padrão, e o thread criado no encadeamento em segundo plano é o encadeamento em segundo plano por padrão. Ao chamar o método setDeamon (true) para definir o thread de primeiro plano como um thread de fundo, ele precisa ser antes do método START () ser chamado. Depois que os tópicos morreram no dia anterior ontem, a JVM notifica o tópico de fundo para morrer, mas leva um certo tempo ao receber as instruções para responder.
4. Altere a prioridade de threads/setPriority ():
Cada encadeamento tem uma certa prioridade ao executar, e os threads com alta prioridade têm mais oportunidades de execução. Cada encadeamento tem a mesma prioridade que o thread que o criou. O encadeamento principal tem prioridade normal por padrão.
Defina a prioridade do thread: setPriority (int priorityLevel). A faixa PriorityLevel PriorityLevel está entre 1-10, e os três valores constantes estáticos comumente usados são os seguintes:
Max_priority: 10
Min_priority: 1
NORM_PRIORIDADE: 5
Obtenha prioridade do thread: getPriority ().
Nota: Um objeto de encadeamento com maior prioridade de encadeamento significa apenas que este thread possui mais oportunidades de execução, em vez de execução prioritária.
classe pública threadtest {public static void main (string [] args) {thread mythread = new mythread (); for (int i = 0; i <100; i ++) {System.out.println ("Thread Indication i ="+i); if (i == 20) {mythread.setPriority (thread.max_priority); mythread.start (); }}}}} classe mythread estende thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("i ="+i); }}}5. Concessões de threads: rendimento ()
O papel básico do rendimento () foi discutido na postagem anterior do blog. Ao mesmo tempo, o método de rendimento () também está relacionado à prioridade do encadeamento. Quando um thread chama o método Eiled () para alternar do estado em execução para o estado pronto, a CPU selecionará apenas threads com a mesma prioridade ou maior prioridade que o encadeamento da fila de encadeamento de estado pronto para executar.
classe pública threadtest {public static void main (string [] args) {thread mythread1 = new mythread1 (); Thread mythread2 = new mythread2 (); mythread1.setPriority (Thread.max_priority); mythread2.setPriority (Thread.min_Priority); for (int i = 0; i <100; i ++) {System.out.println ("Thread Indication i ="+i); if (i == 20) {mythread1.start (); mythread2.start (); Thread.yield (); }}}}} classe mythread1 estende thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("Mythread 1 - i ="+i); }}} classe mythread2 estende thread {public void run () {for (int i = 0; i <100; i ++) {System.out.println ("mythread 2 - i ="+i); }}}Série de artigos:
Explicação das instâncias multi-threaded java (i)
Explicação detalhada das instâncias multi-thread Java (ii)
Explicação detalhada das instâncias multi-threaded Java (iii)