1. Priorität von Threads
Beispiele für die Verwendung von Thread -Priorität:
Paket cn.galc.test; public class testthread6 {public static void main (String args []) {mythead4 t4 = new mythread4 (); MyThread5 T5 = neuer MyThread5 (); Thread T1 = neuer Thread (T4); Thread T2 = neuer Thread (T5); t1.setPriority (thread.norm_priority + 3); // Verwenden Sie die SetPriority () -Methode, um die Priorität von Threads festzulegen, und hier wird die Priorität von T1 -Threads festgelegt/** Erhöhen Sie die Priorität von Thread T1. t1.start (); t2.Start (); System.out.println ("T1 -Thread -Priorität ist:" + t1.getPriority ()); // Verwenden Sie die GetPriority () -Methode, um die Priorität des Threads zu erhalten und die Priorität von T1 auf 8}} Klasse MyThread4 implementiert zu drucken. } }}class MyThread5 implements Runnable { public void run() { for (int i = 0; i <= 1000; i++) { System.out.println("=================== T2:" + i); }}} Sobald die Run () -Methode endet, endet der Thread.2. Fadensynchronisation
Beispiele für synchronisierte Schlüsselwortverbrauch:
Paket cn.galc.test; public class testSync implementiert runnable {timer timer = new Timer (); public static void main (String args []) {Testsync test = new Testsync (); Thread T1 = neuer Thread (Test); Thread T2 = neuer Thread (Test); t1.setName ("t1"); // Setzen Sie den Namen des T1 -Threads T2.SetName ("T2"); // Setzen Sie den Namen des T2 -Threads t1.start (); t2.Start (); } public void run () {timer.add (thread.currentThread (). getName ()); }} Klasse Timer {private static int num = 0; public/ * synchronisiert */void add (String -Name) {// Wenn bei der Deklaration einer Methode synchronisiert wird, bedeutet dies, dass das aktuelle Objekt während der Ausführung dieser Methode synchronisiert ist (dieses). Nur wenn ein Thread zugreift, wird der nächste Thread zugreifen */ num ++; try {thread.sleep (1); } catch (interruptedException e) {e.printstacktrace (); } System.out.println (Name + ": Sie sind die" + num + "-Threads mit Timer"); }}} Faden -Deadlock -Problem:
Paket cn.galc.test;/*Dieses Applet simuliert das Problem des Thread -Deadlocks*/public class testdeadlock implements runnable {public int flag = 1; statisches Objekt O1 = neues Objekt (), O2 = neues Objekt (); public void run () {System.out.println (Thread.currentThread (). getName () + "Flag =" + Flag); /** Nach dem Ausführen des Programms habe ich festgestellt, dass das Programm es ausgeführt und das Flag ausgedruckt hat, und ich werde die nachfolgende Anweisung nie erneut ausführen. } catch (interruptedException e) {e.printstacktrace (); } Synchronized (O2) { /** Objekt O1 wurde zuvor gesperrt, solange es O2 sperren kann, können Sie die Operation des Ausdrucks 1* jedoch nicht ausführen, da das Objekt O1 jedoch nicht in einem anderen Thread -Flag = 0* gesperrt wurde, obwohl der Thread, der Objekt O2, alle 500 Milliseconds schlägt. }}}} /** Beide, wenn Anweisungen hier nicht ausgeführt werden, weil sie das Problem des Thread -Deadlocks* Flag = 1 auf Flag -Waiten aufgewartet haben Flag = 0*/ if (flag == 0) {synchronisiert (O2) {/*Hier verwenden wir synchronisiert, um das Objekt zuerst O2 zu sperren*/ try {thread.sleep (500); } catch (interruptedException e) {e.printstacktrace (); } synchronisiert (O1) { / * * Objekt O2 wurde zuvor gesperrt. Solange es O1 sperren kann, kann der Betrieb von Drucken 0 durchgeführt werden. Das Objekt O1 kann hier jedoch nicht gesperrt werden, da das Objekt O1 in einem anderen FLAG -Faden = 1 gesperrt wurde. Obwohl der Faden, der Objekt O1 sperrt, alle 500 Millisekunden schläft, sperrt er beim Schlafen*/ system.out.println ("0") immer noch O1. }}}} public static void main (String args []) {testdeadlock td1 = new TestDeadlock (); Testdeadlock td2 = new TestDeadlock (); td1.flag = 1; td2.flag = 0; Thread T1 = neuer Thread (TD1); Thread T2 = neuer Thread (TD2); T1.SetName ("Thread Td1"); T2.SetName ("Thread TD2"); t1.start (); t2.Start (); }}Es ist am besten, das Problem der Thread -Deadlocking nur ein Objekt zu lösen, nicht gleichzeitig zwei Objekte.
Hersteller- und Verbraucherfragen:
Paket cn.galc.test;/* Beispielname: Produzent-Konsumer Problem* Quelldateiname: produzierungsumer.java* Schlüsselpunkte:* 1. Inkonsistenz von gemeinsamen Daten/Schutz kritischer Ressourcen* 2. Konzept der Java-Objekt-Lock-Lock* 3. = neuer SyncStack (); Runnable p = neuer Produzent (Stack); Runnable c = neuer Verbraucher (Stack); Thread p1 = neuer Thread (p); Thread C1 = neuer Thread (c); p1.Start (); C1.Start (); }} Klasse SyncStack {// Implementierung von Stapeln, die Multithread -Synchronisationsoperationen private int Index = 0 unterstützen; private char [] data = new char [6]; public synchronisierte void push (char c) {if (index == data.length) {try {this.wait (); } catch (interruptedException e) {}} this.notify (); Daten [Index] = C; Index ++; } public synchronisierte char pop () {if (index == 0) {try {this.wait (); } catch (interruptedException e) {}} this.notify (); Index--; Returndaten [Index]; }} Klasse -Produzent implementiert Runnable {SyncStack Stack; öffentlicher Produzent (SyncStack s) {stack = s; } public void run () {für (int i = 0; i <20; i ++) {char c = (char) (math.random ()*26+'a'); stack.push (c); System.out.println ("produziert:"+c); try {thread.sleep ((int) (math.random ()*1000)); } catch (InterruptedException e) {}}}} Klasse Consumer Implements Runnable {SyncStack Stack; public Consumer (syncStack s) {stack = s; } public void run () {für (int i = 0; i <20; i ++) {char c = stack.pop (); System.out.println ("Verbrauch:"+C); try {thread.sleep ((int) (math.random ()*1000)); } catch (InterruptedException e) {}}}}Das obige ist die vollständige Einführung in Java -Threads. Sie können den ersten Artikel "Java muss Threads lernen (1) lernen" kombinieren, um zu lernen, in der Hoffnung, dass es Ihnen helfen kann.