Dieser Artikel erläutert die Threading-Technologie von Java anhand von Beispielen ausführlicher. Ich glaube, dass er für ein tieferes Verständnis der Java-Programmierung hilfreich sein wird. Die Einzelheiten lauten wie folgt:
Viele Menschen haben beim Erlernen von JAVA ein gewisses Verständnis für Threads, und als wir anfingen, mit der Android-Entwicklung in Kontakt zu treten, stellten wir fest, wie wichtig Threads sind. In diesem Artikel werden wir Ihnen die Erfahrungen mit der Verwendung von Java-Threads mitteilen.
Zunächst muss jeder verstehen, dass Threads und Prozesse nicht dasselbe sind. Was ist ein Prozess? Der Prozess ist genau so, wie wir die Klassendatei ausführen müssen, und der Thread ruft tatsächlich die CPU-Ressourcen zur Ausführung auf. Eine Klassendatei hat im Allgemeinen nur einen Prozess, es können jedoch viele Threads vorhanden sein. Die Ausführung von Threads ist eine asynchrone Ausführungsmethode.
1. So starten Sie einen weiteren Thread in der Hauptfunktion:
Der Beispielcode lautet wie folgt:
public class Thread_one { public static void main(String [] args){ Run run = new Run(); //run.run();//Dies ist ein Methodenaufruf, der sich stark von einem Thread Thread thread = new unterscheidet Thread (run); thread.start();//Starten Sie den Thread und rufen Sie die run()-Methode des Threads auf for(int i=1; i<=20; i++){ System.out.println("Der Wert von main thread i: --------"+i); } }}class Run implementiert Runnable{ @Override public void run() { for(int i=1; i<=20; i++){ System.out .println( "Der Wert des Unterthreads i: "+i); } }}2. Die Schlafmethode in Threads
Der Beispielcode lautet wie folgt:
public class Thread_sleep { /* * Thread pause*/ public static void main(String [] args){ Runone run = new Runone(); thread = new Thread(run thread.start(); (5000); thread.interrupt();//Unterbrechen Sie die Ausführung des Threads//thread.stop();//Im Vergleich zum Unterbrechen des Threads ist Stop zu grob und wird im Allgemeinen nicht empfohlen Das Schließen des untergeordneten Threads muss erzwungen werden. } Catch (InterruptedException e) { e.printStackTrace(); } }}class Runone implementiert Runnable{ @Override public void run() { for(int i=1; i<10; i++ ){ try { Thread.sleep(1000 ); System.out.println("-----"+new Date()+"-----" } Catch (InterruptedException e) { return ;// Wenn festgestellt wird, dass der untergeordnete Thread unterbrochen ist, schließen Sie den untergeordneten Thread direkt.} } }}Ein besonderer Hinweis hier ist, dass thread.interrupt(); die Ausführung eines Threads unterbrechen kann. Dies ist etwas sanfter als stop, aber es ist nicht die beste Möglichkeit, einen Thread zu schließen.
public class Thread_stop { public static void main(String [] args){ Run three run = new Run three(); Thread th = new Thread(run th.start(); InterruptedException e) { e.printStackTrace(); }class Run three implementiert Runnable{ boolean flag; { flag = true; while(flag){ try { System.out.println("child thread----"+(i++)); Thread.sleep(1000 } Catch (InterruptedException e) { e.printStackTrace(); flag = false; } }Lassen Sie mich Ihnen das Zusammenführen und Verschenken in Threads kurz vorstellen:
1. So führen Sie Threads zusammen : Hier wird die Methode join () aufgerufen
Der Beispielcode lautet wie folgt:
public class Thread_join { /* * Threads zusammenführen*/ public static void main(String [] args){ Runtwo run = new Runtwo(); thread = new Thread(run thread.start(); ();//Threads zusammenführen, dies entspricht dem Methodenaufruf} Catch (InterruptedException e) { e.printStackTrace(); } for(int i=0; i<10; i++){ System.out.println("main Thread: "+i); } }}class Runtwo implementiert Runnable{ @Override public void run() { for(int i=0; i<10; i++){ System.out.println("Untergeordneter Thread: --- -"+i); } } }2. So geben Sie den Thread auf : Die yield()-Methode von Thread wird hier aufgerufen, wie unten gezeigt:
public class Thread_yield { /**CPU aufgeben * @param args */ public static void main(String[] args) { Th th = new Th("aaa"); for(int i = 0 ; i<=10; i++){ System.out.println("Main thread----"+i } }}class Th erweitert Thread{ Th(){} Th(String s){super(s) ;} @Override public void run() { for(int i = 0; i<=10; i++){ if(i%3!=0){ System.out.println("child thread"+i } else{ System.out.println("Sub-thread i="+i+" Thread Switches"); yield();//Diese Methode kann nur verwendet werden, wenn Sie von Thread erben} } }}Abschließend möchte ich Ihnen das Problem der Thread-Priorität mitteilen. Der Code lautet wie folgt:
public class Thread_priority { /* * Priority legt die Priorität des Threads fest * Die Standardpriorität von Thread ist 5; die maximale Priorität von Thread ist 10 und die minimale ist 0 */ public static void main(String [] args){ T1 t1 = new T1(); T2 t2 = new T2(); t1.setPriority(Thread.NORM_PRIORITY+3); //Setzen Sie die Priorität von t1 t2.start(); erweitert Thread { @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T1-----"+i} }}class T2 erweitert Thread{ @Override public void run() { for(int i = 0; i<50; i++){ System.out.println("Thread T2"+i);Ich glaube, dass Sie den Threading-Mechanismus in JAVA durch den obigen Code im Grunde verstanden haben. Ich hoffe, dass die Beschreibung in diesem Artikel Ihnen bei Ihrem eingehenden Studium der Java-Programmierung hilfreich sein wird.