Java wait(): So verwendest du die Java wait Methode!

Beim Arbeiten in einer Multi-Thread-Umgebung können mehrere Threads (auch: Vorgänge) versuchen, auf die gleiche, blockierte Ressource zuzugreifen. In einer solchen Situation kann eine fehlerhafte Verwaltung dieser Threads zu Inkonsistenzen führen. In Java kannst du die sog. „guarded blocks“ verwenden, um die Operationen mehrerer Threads zu koordinieren. Diese Blöcke prüfen, ob eine bestimmte Bedingung erfüllt ist, bevor die Ausführung des Threads fortgesetzt wird.

Genauer gesagt wird die Java wait() Methode von diesen Blöcken verwendet, um die Ausführung eines Threads auszusetzen, und die Methode „notify()„, um den Thread in der Warteschlange wieder aufzuwecken.

In diesem Artikel wird die Funktionsweise und Verwendung der Java Methode wait() erläutert. So, lass uns loslegen!

Was ist die Java wait() Methode?

Die Klasse „java.lang.Object“ enthält die Methode „wait()„. Wenn diese „wait()“ Methode für ein Objekt aufgerufen wird, wechselt der zugehörige Thread vom „running“ (“laufenden“) in einen „waiting“ (“wartenden“) Zustand. Danach wartet er darauf, dass ein anderer Thread die Methode „notify()“ oder „notifyAll()“ aufruft, um den Thread wieder in den „runnable“ (“lauffähigen“) Zustand zu versetzen.

Syntax

wait()

Wie funktioniert die Java wait() Methode?

„Synchronisierte“ Blöcke und Methoden in Java erlauben nur einem Thread, eine Ressource zu blockieren. Wenn also der Java Thread die Methode „wait()“ aufruft, gibt er die Sperre dieser spezifischen Ressource frei, und der Thread wird zur Warteschlange hinzugefügt, bis ein anderer Thread die Methoden „notifyAll()“ oder „notify()“ aufruft.

Die Methode „notify()“ kann immer nur einen Thread aufwecken, während die Methode „notifyAll()“ alle Threads aufwecken kann, die sich auf dasselbe Objekt beziehen und zuvor der Warteschlange hinzugefügt wurden. Beide Java Methoden geben die Blockierung des Objekts nicht frei, sondern werden dazu verwendet, die zur Warteschlange hinzugefügten Threads aufzuwecken.

Sehen wir uns nun die Implementierung der Java Methode „wait()“ an.

Wie verwendet man die Java wait()-Methode?

Betrachten wir ein Szenario, in dem insgesamt 50 Schüler in der Klasse sind. Der Unterricht beginnt erst, wenn alle Schüler/innen eingetroffen sind. Um das zu ermöglichen werden wir mit der Java wait()-Methode arbeiten!

class Student {
    int noOfStudents = 50;
    synchronized void printStudentDetails(int students) {
        int stdCount = 0;
        while (stdCount < 50) {
            stdCount++;
        }
        if (noOfStudents < students) {
            System.out.println("Wir haben zu wenig Schüler im Klassenraum!");
            try {
                System.out.println("Warten wir lieber mal auf die restlichen Schüler...");
                wait();
            } catch (Exception e) {}
        }
        System.out.println("Anzahl der Schüler (nach der notify()-Methode): " + noOfStudents);

        System.out.println("Wir haben genug Schüler beisammen");
        System.out.println("Der Unterricht beginnt nun!");
    }
    synchronized void addStudent(int noOfStudents) {
        this.noOfStudents += noOfStudents;
        notify();
    }
}

In der Methode „main()“ unserer Klasse „Main“ deklarieren wir eine Instanz der Klasse „Student“ und erstellen zwei neue Threads. Beide Threads werden die Methode „printStudentDetails“ aufrufen, nur mit unterschiedlichen Parametern:

public class Main {
    public static void main(String[] args) {
        Student stdObj = new Student();
        new Thread() {
            @Override
            public void run() {
                stdObj.printStudentDetails(60);
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                stdObj.printStudentDetails(50);
            }
        }.start();
    }
}

Das oben stehende Programm wird in den folgenden Schritten ausgeführt:

• In diesem Beispielprogramm haben wir zwei Klassen „Student“ und „Main“ erstellt.
• Außerdem haben wir zwei Threads innerhalb der main-Methode der Main-Klasse erstellt.
• Der erste Thread gibt die Anzahl der Schüler aus, während der zweite Thread weitere Schüler zur Klasse hinzufügt.
• Die Klasse Student prüft, ob die Gesamtzahl der Schüler/innen kleiner ist als der vom Benutzer angegebene Wert? Wenn ja! Dann warte auf weitere Schüler, d.h. die Methode wait() wird aufgerufen.
• Der zweite Thread fügt der Klasse weitere Schüler hinzu und ruft anschließend die Methode notify() auf, um den Thread wieder in den „lauffähigen“ Zustand zu versetzen.
• Wenn der Code erfolgreich ausgeführt wird, erhalten wir die unten stehende Ausgabe:

Das waren alle wesentlichen Informationen über die Java Methode „wait()„. Du kannst bei Bedarf gerne weiter recherchieren.

Zusammenfassung: Java wait

Die Methode Java wait() ist ein Teil der Klasse „java.lang.Object„, die bei einem Objekt aufgerufen wird, um den zugehörigen Thread von einem „running“ (“laufenden“) in einen „waiting“ (“wartenden“) Zustand zu versetzen. Danach wartet sie darauf, dass ein anderer Thread die Methode „notify()“ oder „notifyAll()“ aufruft, um den Thread wieder in den „runnable“ (“lauffähigen“) Zustand zu versetzen, der sich in der Warteschlange befindet. In diesem Beitrag haben wir die Funktionsweise der Java Methode wait() besprochen und ihre Verwendung anhand eines geeigneten Beispiels demonstriert. Falls du mehr über Java lernen willst, schau hier nach!