1. Thread beitreten :
Während der Thread-Ausführung möchten Sie manchmal, dass ein anderer Thread zuerst ausgeführt wird, z. B. indem Sie ein großes Problem in viele kleine Probleme aufteilen und jedem kleinen Problem einen Thread zuweisen. Nachdem jedoch alle kleinen Probleme verarbeitet wurden, lassen Sie den Hauptthread weitere Vorgänge ausführen. Zu diesem Zeitpunkt können wir die join()-Methode anderer Threads im Hauptthread aufrufen, um den aufrufenden Thread (hier den Hauptthread) zu blockieren.
Beispielcode:
Kopieren Sie den Codecode wie folgt:
Paket org.frzh.thread;
öffentliche Klasse JoinThread erweitert Thread{
//Stellen Sie einen parametrisierten Konstruktor bereit, um den Namen des Threads festzulegen
public JoinThread(String name) {
super(Name);
}
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) {
//Untergeordneten Thread starten
new JoinThread("neuer Thread").start();
for (int i = 0; i < 100; i++) {
if (i == 20) {
JoinThread jt = new JoinThread("Thread, dem beigetreten werden soll");
jt.start();
// Der Hauptthread ruft die Join-Methode des JT-Threads auf. Anschließend muss der Hauptthread warten, bis die Ausführung von JT abgeschlossen ist, bevor er ausgeführt werden kann
versuchen {
jt.join();
} Catch (InterruptedException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " " +i);
}
}
}
Ursprünglich gab es drei Sätze von Threads (zwei Unter-Threads und ein Haupt-Thread). Wenn i=20, ist der Haupt-Thread blockiert und muss warten, bis der „verbundene Thread“ ausgeführt wird, bevor er ausgeführt werden kann werden danach nur noch zwei Threads ausgeführt.
Drei überladene Formen der join()-Methode:
join(): Warten Sie, bis die Ausführung des verbundenen Threads abgeschlossen ist.
join(long millis): Die längste Zeit, die auf die Ausführung des verbundenen Threads gewartet wird, beträgt Mills Millisekunden. Danach wird der verbundene Thread nicht länger warten.
join(long millis, int nanos): Die maximale Wartezeit auf die Ausführung des verbundenen Threads beträgt Millis Millisekunden + Nanos Mikrosekunden. (Diese Methode ist grundsätzlich nutzlos).
2: Hintergrundthread :
Es gibt einen Thread, der im Hintergrund läuft und dessen Aufgabe es ist, andere Threads zu bedienen. Dieser Thread wird als „Hintergrund-Thread“, „Daemon-Thread“ oder „Elf-Thread“ bezeichnet. Wenn alle Vordergrund-Threads sterben, stirbt auch der Hintergrund-Thread automatisch.
Beispielcode:
Kopieren Sie den Codecode wie folgt:
Paket org.frzh.thread;
Die öffentliche Klasse DaemonThread erweitert Thread{
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(getName() + " " +i);
}
}
public static void main(String[] args) {
DaemonThread dt = new DaemonThread();
//Diesen Thread als Hintergrundthread festlegen
dt.setDaemon(true);
dt.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
// Der Vordergrund-Thread endet, dann wird auch der Hintergrund-Thread dt beendet, sodass 999 nicht ausgeführt wird
}
}
Der Hauptthread ist standardmäßig der Vordergrundthread, die vom Vordergrundthread erstellten Unterthreads sind standardmäßig der Vordergrundthread und die vom Hintergrundthread erstellten Unterthreads sind standardmäßig der Hintergrundthread.
3. Thread-Schlaf (Schlaf):
Die vorherige Join-Methode besteht darin, den aufrufenden Thread warten zu lassen, bis die Ausführung des verbundenen Threads abgeschlossen ist, bevor er fortfährt, während die Sleep()-Methode den aufrufenden Thread eine Zeit lang blockieren lässt, bevor er wieder in den Bereitschaftszustand wechselt und darauf wartet geplant. Daher wird es oft verwendet, um die Programmausführung anzuhalten.
Beispielcode:
Kopieren Sie den Codecode wie folgt:
Paket org.frzh.thread;
import java.util.Date;
öffentliche Klasse SleepThread{
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println("Aktuelle Zeit: " + neues Datum());
versuchen {
Thread.sleep(1000);
} Catch (InterruptedException e) {
// TODO Automatisch generierter Catch-Block
e.printStackTrace();
}
}
}
}
Zwei Überladungsmethoden der Sleep()-Methode:
statischer Void-Schlaf (lange Millisekunden): Lassen Sie den aktuellen Thread für Millisekunden pausieren und wechseln Sie in den Blockierungszustand. Diese Methode wird von der Präzision und Genauigkeit der Systemzeitgeber und Thread-Scheduler beeinflusst.
statischer Void-Schlaf (lange Millisekunden, int Nanos): Pausieren Sie Mills Millisekunden + Nanos Mikrosekunden und wechseln Sie in den Blockierungszustand. Dies wird auch von der Genauigkeit und Genauigkeit des System-Timers und Thread-Planers beeinflusst. Im Grunde nicht nötig.
4. Fadenausbeute :
Die yield()-Methode ähnelt in gewisser Weise der Sleep-Methode. Sie kann auch den aktuell laufenden Thread anhalten, blockiert den Thread jedoch nicht, sondern versetzt ihn nur in den Bereitschaftszustand (beachten Sie, dass es sich nicht um einen Blockierungszustand handelt). Die yield()-Methode gibt nur Threads mit der gleichen oder einer höheren Priorität die Chance, ausgeführt zu werden, sodass ein Thread nach dem Aufruf dieser Methode möglicherweise erneut geplant wird, um die Ausführung fortzusetzen.
Beispielcode:
Kopieren Sie den Codecode wie folgt:
Paket org.frzh.thread;
Die öffentliche Klasse YieldThread erweitert Thread{
public YieldThread() {
}
public YieldThread(String name) {
super(Name);
}
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + " " +i);
if (i == 20) {
//Der aktuelle Thread ergibt
Thread.yield();
}
}
}
public static void main(String[] args) {
//Zwei gleichzeitige Threads starten
YieldThread yt1 = new YieldThread("Advanced");
//Setze yt1 als höchste Priorität
yt1.setPriority(Thread.MAX_PRIORITY);
yt1.start();
YieldThread yt2 = new YieldThread("low-level");
yt2.setPriority(Thread.MIN_PRIORITY);
yt2.start();
/*
* Wenn die Priorität für den Thread nicht festgelegt ist, ist die Priorität der beiden Threads gleich, sodass die beiden Threads abwechselnd ausgeführt werden und der andere Thread ausgeführt wird, wenn yield aufgerufen wird.
* Nachdem jedoch die oben genannten Prioritäten für die beiden Threads festgelegt wurden, wird die erweiterte Thread-Ausführung gerade erst gestartet. Wenn i = 20 ist, wird yield aufgerufen, da dies jedoch nur der Fall ist
* Geben Sie Threads mit derselben oder höherer Priorität Ausführungsmöglichkeiten, sodass der Thread auf hoher Ebene zu diesem Zeitpunkt noch ausgeführt wird und nicht an Threads auf niedriger Ebene vergeben wird
*/
}
}
5: Ändern Sie die Priorität des Threads :
Dies ist relativ einfach. Rufen Sie einfach die Instanzmethode setPriority(int Priority) auf. Jeder Thread hat standardmäßig die gleiche Priorität wie sein übergeordneter Thread, und der Hauptthread hat standardmäßig die normale Priorität (5). Java bietet Prioritäten von 1 bis 10, und Sie können auch drei statische Konstanten verwenden:
MAX_PRIORITY:10
MIN_PRIORITÄT:1
NORM_PRIORITY:5
Hinweis: Obwohl Java 10 Prioritäten bereitstellt, unterstützen verschiedene Systeme unterschiedliche Prioritäten. Vermeiden Sie daher die direkte Verwendung von Zahlen zwischen 1 und 10 und verwenden Sie statische Konstanten, um eine gute Portabilität sicherzustellen.