Verwendung der Join-Methode bei der gleichzeitigen Java-Programmierung

Einführung

Bei der Multithread-Programmierung kann die Ausführung eines Threads manchmal vom Ausführungsergebnis eines anderen Threads abhängen. JDK bietet die Join-Methode, um diese Funktion zu erreichen.

Wenn wir die Join-Methode für den Thread aufrufen, wechselt der aufrufende Thread in den Wartezustand. Es bleibt im Wartezustand, bis die Ausführung des referenzierten Threads abgeschlossen ist.

join und seine Überladungsmethode:

1. join () , warte auf das Ende der Thread-Ausführung.
2. join (long millis) , ähnlich der join () -Methode, mit einem zusätzlichen millis-Parameter, der die maximale Anzahl von Millisekunden angibt, die auf die Ausführung des Threads gewartet werden soll. join (0) entspricht join ().
3. Die Join-Methode (Long Millis, Int Nanos) entspricht der Join-Methode (Long Millis), mit der Ausnahme, dass die Wartezeit eine höhere Genauigkeit aufweist.

Grundlegende Verwendung der Join-Methode

Der Hauptthread wartet auf das Ende des untergeordneten Threads und setzt die Ausführung fort:

// java 项目 www.fhadmin.org 
public class Demo { 
    public statisch void main (String [] args) löst InterruptedException aus { 
        Thread thread = new Thread (() -> { 
            try { 
                Thread.sleep (3000); 
            } catch (InterruptedException) e) { 
                e.printStackTrace (); 
            } 

            System.out.println ("数据 加载 中 ..."); 
        }); 

        thread.start (); 
        thread.join (); 

        System.out.println ("数据 加载 完毕"); 
    } 
}

Ausgabeergebnis:

Laden von 
Daten ... Laden von Daten abgeschlossen

Legen Sie die maximale Wartezeit fest. Nach dieser Zeit wird der Hauptthread weiterhin ausgeführt, anstatt auf das Ende der Ausführung des untergeordneten Threads zu warten:

// java 项目 www.fhadmin.org 
public class Demo { 
    public statisch void main (String [] args) löst InterruptedException aus { 
        Thread thread = new Thread (() -> { 
            try { 
                Thread.sleep (3000); 
            } catch (InterruptedException) e) { 
                e.printStackTrace (); 
            } 

            System.out.println ("数据 加载 中 ..."); 
        }); 

        thread.start (); 
        thread.join (1000); 

        System.out.println ("数据 加载 完毕"); 
    } 
}

Ausgabeergebnis:

Das Laden der Daten ist abgeschlossen. 
Das Laden der Daten ...

Quellcode der Join-Methode

Der Quellcode der Join-Methode lautet wie folgt:

// Java-Projekt www.fhadmin.org 
public final synchronized void join (long millis) löst InterruptedException aus { 
	long base = System.currentTimeMillis (); 
	long now = 0; 

	// Wenn die Wartezeit kleiner als 0 ist, wird IllegalArgumentException direkt ausgelöst, 
	wenn (millis <0) { 
		neue IllegalArgumentException auslösen ("Timeout-Wert ist negativ"); 
	} 

	// Wartezeit ist 0, rufe wait (0) auf und warte, bis der Thread beendet ist. (join (0) entspricht dem Aufruf von wait (0) entspricht dem Aufruf von wait ()) 
	if (millis == 0) { 
		while (isAlive ()) { 
			wait (0); 
		} 
	} else { 
		// Beim Warten Die Zeit ist größer als 0, auch wenn das Aufwachen auf halbem Weg, solange die Wartezeit nicht überschritten wird, immer noch in den Wartezustand wechselt. 
		while (isAlive ()) { 
			lange Verzögerung = Millis-Now; 
			if (Verzögerung <= 0) { 
				Pause; 
			} 
			Wartezeit (Verzögerung);
			now = System.currentTimeMillis () - base; 
		} 
	} 
}

Aus dem Quellcode der Join-Methode ist ersichtlich, dass das Wesentliche der Join-Methode darin besteht, die Wartemethode des Thread-Objekts aufzurufen. Wenn die Join-Methode aufgerufen wird, muss die Sperre des Thread-Objekts erfasst werden Die Wartemethode des Thread-Objekts wird aufgerufen. Nach dem Ende des Threads wird das Thread-Objekt automatisch als notifyAll-Methode bezeichnet.

Wenn wir also eine Synchronisierung durchführen, sollten wir vermeiden, das Thread-Objekt als Sperrobjekt zu verwenden, da dies die Arbeit der System-API beeinträchtigen kann.