Este artigo explica a tecnologia de threading Java com mais detalhes com exemplos. Acredito que será útil para uma compreensão profunda da programação Java. Os detalhes são os seguintes:
Muitas pessoas têm um certo conhecimento de threads ao aprender JAVA, e quando começamos a entrar em contato com o desenvolvimento Android, descobrimos realmente a importância dos threads. Este artigo compartilhará com você a experiência de usar threads Java para sua referência.
Em primeiro lugar, todos devem compreender que threads e processos não são a mesma coisa. O processo é exatamente como precisamos para executar o arquivo de classe, e o thread é o que realmente chama os recursos da CPU para execução. Um arquivo de classe geralmente possui apenas um processo, mas pode haver muitos threads. A execução de threads é um método de execução assíncrona.
1. Como iniciar outro thread na função principal:
O código de exemplo é o seguinte:
public class Thread_one { public static void main(String [] args){ Run run = new Run(); //run.run();//Esta é uma chamada de método, que é muito diferente de um thread Thread thread = new Thread (run); thread.start();//Inicie o thread e chame o método run() do thread for(int i=1; i<=20; i++){ System.out.println("O valor de main thread i: --------"+i); } }}class Run implements Runnable{ @Override public void run() { for(int i=1; i<=20; i++){ System.out .println( "O valor do subthread i: "+i } }}2. O método sleep em threads
O código de exemplo é o seguinte:
public class Thread_sleep { /* * Thread pause*/ public static void main(String [] args){ Runone run = new Runone thread = new Thread(run()); (5000); thread.interrupt();//Interrompe a execução do thread//thread.stop();//Comparado à interrupção do thread, stop é muito brusco e não é recomendado. thread filho precisa ser forçado a fechar. } catch (InterruptedException e) { e.printStackTrace(); } }}class Runone implements Runnable{ @Override public void run() { for(int i=1; i<10; i++ ){ tente { Thread.sleep(1000 ); System.out.println("-----"+new Date()+"-----" } catch (InterruptedException e) { return ;// Quando for detectado que o thread filho foi interrompido, feche o thread filho diretamente} } }}Uma observação especial aqui é que thread.interrupt(); pode interromper a execução de um thread. É um pouco mais suave que parar, mas não é a melhor maneira de fechar um thread.
classe pública Thread_stop { public static void main(String [] args){ Runtrês run = new Runtrês Thread th = new Thread (run()); InterruptedException e) { e.printStackTrace(); run.setStop(); }}class Runtrês implementa Runnable{ sinalizador booleano; { System.out.println("thread filho----"+(i++)); Thread.sleep(1000 } catch (InterruptedException e) { e.printStackTrace(); bandeira = falso; } }Deixe-me apresentar brevemente a você a fusão e distribuição em tópicos:
1. Como mesclar threads , o método join() é chamado aqui
O código de exemplo é o seguinte:
public class Thread_join { /* * Mesclar threads*/ public static void main(String [] args){ Runtwo run = new Runtwo Thread thread = new Thread(run()); ();//Mesclar threads, isso é equivalente à chamada do método} catch (InterruptedException e) { e.printStackTrace() } for(int i=0; i<10; i++){ System.out.println("main Tópico: "+i); } }}class Runtwo implements Runnable{ @Override public void run() { for(int i=0; i<10; i++){ System.out.println("Thread filho: --- -"+i); } } }2. Como desistir do thread O método yield() do Thread é chamado aqui, conforme mostrado abaixo:
public class Thread_yield { /**Desistir da CPU * @param args */ public static void main(String[] args) { Th th = new Th("aaa"); ; i<=10; i++){ System.out.println("Thread principal----"+i); ;} @Override public void run() { for(int i = 0; i<=10; i++){ if(i%3!=0){ System.out.println("thread filho"+i }); else{ System.out.println("Sub-thread i="+i+" thread switches"); //Este método só pode ser usado se você herdar de Thread} } }}Por fim, gostaria de compartilhar com vocês a questão da prioridade do thread . O código é o seguinte:
public class Thread_priority { /* * prioridade define a prioridade do thread * A prioridade padrão do Thread é 5; a prioridade máxima do Thread é 10 e a mínima é 0 */ public static void main(String [] args){ T1 t1 = new T1(); T2 t2 = new T2(); //t1.setPriority(Thread.NORM_PRIORITY+3); estende Thread { @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T1-----"+i); Thread{ @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T2"+i);Acredito que você basicamente entendeu o mecanismo de threading em JAVA por meio do código acima. Espero que o que este artigo descreve seja útil para você em seu estudo aprofundado de programação Java.