Apresentei brevemente o uso do Java Multi-Threading. Eu já introduzi a classe Thread e a classe executável. Para entender melhor o multi-threading, este artigo realiza uma análise detalhada do thread.
começar()
Vamos primeiro dar uma olhada na introdução deste método na API:
Faz com que o tópico comece a executar; A máquina virtual Java chama o método de execução do Thread.
O resultado é que dois threads são executados simultaneamente; O thread atual (retornado da chamada para o método inicial) e o outro thread (executando seu método de execução).
É ilegal iniciar um tópico várias vezes. Especialmente quando o tópico terminou de executar, ele não pode ser reiniciado.
Use o método Iniciar para iniciar o thread, que realmente realiza multi-threading. No momento, você não precisa esperar o código do corpo do método de execução para concluir a execução e continuar executando o código a seguir diretamente. Um thread é iniciado chamando o método START () da classe Thread. Neste momento, o thread está em um estado pronto (executável) e não está em execução. Depois que a fatia de tempo da CPU é obtida, o método run () começa a ser executado. Aqui, o método run () é chamado de corpo de thread. Ele contém o conteúdo do thread a ser executado. O método de execução termina e o encadeamento termina imediatamente.
O método inicial é um método para iniciar o thread. Depois de usá -lo, o Java criará um novo thread para executar o método em execução. Aqui está uma pequena demonstração:
para (int i = 0; i <3; i ++) {thread t = new Thread (new Runnable () {@Override public void run () {System.out.println (thread.currentThread (). getName ()+"start"; Try {Thread.sleep (1st);} (Catch ()+" System.out.println (Thread.currentThread (). GetName ()+"end"); t.start (); } System.out.println ("It's Over"); Resultados da execução:
acabou
Thread-1 inicial
Start thread-0
Thread-2 Iniciar
Thread-0 final
Thread-1 final
Thread-2 final
Como o multithreading é aleatório, os resultados podem ser diferentes a cada vez, o que também é algo que precisamos prestar atenção. A ordem de execução e a ordem de chamada dos threads não são consistentes.
correr()
O método de execução é chamar o método de execução de execução definida por thread e modificar a demonstração acima:
para (int i = 0; i <3; i ++) {thread t = new Thread (new Runnable () {@Override public void run () {System.out.println (thread.currentThread (). getName ()+"start"; Try {Thread.sleep (1st);} (Catch ()+" System.out.println (Thread.currentThread (). GetName ()+"end"); t.run (); } System.out.println ("It's Over"); Resultados da execução:
início principal
final principal
início principal
final principal
início principal
final principal
acabou
O resultado direto do método de execução é muito diferente do início. É executado em ordem e não abre um novo thread.
parar()
O método de parada é forçar interromper a execução do thread. Não é seguro, então não use esse método. Quando a parada for chamada, os recursos bloqueados serão lançados, mas essa versão é inconsistente e pode causar facilmente problemas do programa. Se você deseja controlar a parada do thread, pode usar variáveis personalizadas para julgar ou ISInterrupted () Método:
classe Thread1 estende Thread {@Override public void run () {// julga se o corpo do thread está funcionando enquanto (! isInterrupted ()) {// faz algo}}} interromper()
A função da interrupção é notificar o encadeamento que você foi interrompido, mas a execução de interrupção específica requer processamento personalizado do thread e você pode até ignorá -lo e continuar a execução. A solidão específica é lançar uma interrupção ao encadear a execução dos métodos de junção, espera e sono.
Thread t1 = new Thread (novo runnable () {@Override public void run () {System.out.println (thread.currentThread (). GetName ()+"start"); tente {para (int i = 0; i <100000; i ++) {System.out.println (i+""); System.out.println ("O thread é interrompido"); // você pode fazer a liberação de recursos, o log, etc. E.PrintStackTrace (); t1.start (); Thread.sleep (100); t1.Interrupt ();Resultados da execução:
65666768 O tópico é interrompidojava.lang.interruptEdException: Sleep InterruptEdThread-0 final em java.lang.thread.sleep (método nativo) em com.wk.aqi.act.test $ 1.run (test.java:23) em java.lang.thread.run.run (test.java:23) em java.lang.thread.run.run (Test.java:23) em java.lang.thread.r.
ISInterrupted ()
Para determinar se o encadeamento é interrompido, depois de executar o método de interrupção acima, ele retornará true.
SetPriority (int NewPriority) e GetPriority ()
Defina a prioridade dos threads e obtenha a prioridade dos threads. Os recursos alocados pela CPU estão focados em tópicos com prioridades mais altas.
Thread t1 = new Thread (new Runnable () {@Override public void run () {long t = System.currenttimEmillis (); System.out.println (thread.currentThread (). TODO BLOCO DE CATURA AUTOMADO E.PRINTSTACKTRACE (); Thread t2 = new Thread (new Runnable () {@Override public void run () {long t = System.currenttimEmillis (); System.out.println (thread.currentThread (). TODO BLOCO DE CATURA AUTOMÁRIO E.PrintStackTrace (); t1.setPorority (10); T2.SetPorority (1); t2.start (); t1.start ();Resultados da execução:
Thread-0 startThread-1 startThread-0 t1 final 1357thread-1 t2 end 1371
Quando a prioridade é a mesma, T1 e T2 são concluídos quase ao mesmo tempo, e há diferenças óbvias quando a prioridade é diferente.
getName ()
É relativamente simples, obtenha o nome do tópico.
ingressar () e ingressar (Millis Long)
A função do método Jion é aguardar a conclusão da execução do encadeamento e a participação (Millis Long) pode definir o tempo máximo de espera. Por exemplo, o encadeamento principal precisa esperar que o thread infantil conclua e obtenha o resultado do thread infantil antes de continuar a executar. Neste momento, você pode usar o método de junção.
Thread t1 = new Thread (new Runnable () {@Override public void run () {long t = System.CurrentTimEmillis (); System.out.println (thread.currentThread (). E.PrintStackTrace (); t1.start (); t1.Join (); System.out.println ("Aguardando o T1 ser executado antes de executar");Resultados da execução:
Thread-0 startThread-0 t1 final 1001 aguarde para que o T1 seja executado antes de executar
Resumir
O exposto acima é toda a explicação detalhada do código do método de implementação do thread Java multi-thread, espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la.