So verwenden Sie die Objektmethoden „wait“ und „notify“ in Java korrekt

So verwenden Sie Objektmethoden in Java richtig: Warten und Benachrichtigen

In Java sind Warten und Benachrichtigen wichtige Methoden, die verwendet werden, um die Zusammenarbeit zwischen mehreren Threads zu erreichen. Durch die korrekte Verwendung dieser beiden Methoden können Multithreading-Probleme wie Rennbedingungen und Deadlocks vermieden und die Sicherheit und Effizienz des Programms gewährleistet werden. In diesem Artikel wird die korrekte Verwendung der Objektmethoden „wait“ und „notify“ in Java vorgestellt und spezifische Codebeispiele bereitgestellt.

1. Die Grundprinzipien und Funktionen von Warten und Benachrichtigen

Bevor Sie verstehen, wie Sie Warten und Benachrichtigen richtig verwenden, müssen Sie deren Grundprinzipien und Funktionen verstehen.

1. wait: Versetzen Sie den aktuellen Thread in einen Wartezustand, bis andere Threads ihn über die Methode notify oder notifyAll aufwecken. Durch die Verwendung der Wartemethode kann die Sperre des Objekts effektiv aufgehoben und der aktuelle Thread blockiert werden, wodurch die Ausführung unterbrochen wird.
2. notify: Weckt einen Thread auf, der auf das Objekt wartet. Wenn mehrere Threads warten, aktiviert notify nur einen Thread nach dem Zufallsprinzip, und der spezifische Thread, der aktiviert werden soll, ist ungewiss.
3. notifyAll: Weckt alle Threads auf, die auf dieses Objekt warten. Verwenden Sie die notifyAll-Methode, um alle wartenden Threads aufzuwecken. Welcher Thread jedoch aufgeweckt werden soll, hängt vom Thread-Scheduler ab.

2. Schritte zur korrekten Verwendung von Warten und Benachrichtigen

Um Warten und Benachrichtigen korrekt zu verwenden, müssen Sie die folgenden Schritte ausführen:

1. Sperren: Wenn Sie Warten und Benachrichtigen verwenden, müssen Sie zunächst die Sperre des Objekts erhalten. Sie können das synchronisierte Schlüsselwort zum Sperren oder das Lock-Objekt zum Sperren verwenden.
2. Rufen Sie die Wartemethode auf: Rufen Sie vor dem Betreten des kritischen Abschnitts die Wartemethode des Sperrobjekts auf, um den aktuellen Thread in einen Wartezustand zu versetzen.
3. Bedingte Beurteilung: Vor dem Betreten des kritischen Abschnitts sollten zunächst die Bedingungen der gemeinsam genutzten Ressourcen überprüft werden. Wenn die Bedingung nicht erfüllt ist, sollten Sie weiterhin warten, bis die Bedingung erfüllt ist.
4. Sperre freigeben: Nach dem Aufruf der Wartemethode gibt der aktuelle Thread die Sperre des Objekts frei, sodass andere Threads den kritischen Abschnitt betreten können, um gemeinsam genutzte Ressourcen zu betreiben.
5. Notify- oder notifyAll-Methode aufrufen: Wenn die Bedingungen erfüllt sind, können Sie die notify- oder notifyAll-Methode des Sperrobjekts aufrufen, um den wartenden Thread aufzuwecken.
6. Relock: Der erwachte Thread erhält die Sperre des Objekts zurück und konkurriert weiterhin um die Ausführung.

3. Spezifische Codebeispiele

Das folgende Codebeispiel zeigt, wie man „wait“ und „notify“ richtig verwendet, um eine Zusammenarbeit zwischen zwei Threads zu erreichen. Ein Thread ist dafür verantwortlich, darauf zu warten, geweckt zu werden, und der andere Thread ist für das Aufwachen verantwortlich.

public class WaitNotifyExample {
    private static final Object lock = new Object();
    private static boolean isReady = false;

    public static void main(String[] args) {
        Thread waitingThread = new Thread(() -> {
            synchronized (lock) {
                while (!isReady) {
                    try {
                        System.out.println("等待中...");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("等待结束！");
            }
        });

        Thread notifyingThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("唤醒等待的线程...");
                isReady = true;
                lock.notify();
            }
        });

        waitingThread.start();
        notifyingThread.start();
    }
}

Führen Sie den obigen Code aus und Sie können sehen, dass der wartende Thread nach dem Aufwecken in den Wartezustand wechselt und die Ausführung fortsetzt.

In diesem Beispiel verwenden wir eine gemeinsam genutzte boolesche Variable isReady, um die Wartebedingung darzustellen. Der wartende Thread prüft isReady, bevor er in den kritischen Abschnitt eintritt. Wenn die Bedingung nicht erfüllt ist, wird die Wartemethode aufgerufen, um in den Wartezustand zu gelangen. Nachdem der Weckthread die Bedingung erfüllt, ändert er den Wert von isReady und ruft die Benachrichtigungsmethode auf, um den wartenden Thread aufzuwecken.

Es ist zu beachten, dass Sie bei Verwendung von Wait und Notify sicherstellen müssen, dass der Thread die Sperre desselben Objekts erhält. Andernfalls kann der Thread nicht ordnungsgemäß in den Wartezustand wechseln oder aktiviert werden.

Zusammenfassung

Durch die Verwendung der Warte- und Benachrichtigungsmethoden kann eine Zusammenarbeit zwischen mehreren Threads erreicht und die Sicherheit und Effizienz des Programms gewährleistet werden. Wenn Sie diese beiden Methoden verwenden, müssen Sie die richtigen Schritte befolgen, einschließlich Sperren, Aufrufen der Wartemethode, Überprüfen der Bedingungen, Aufheben der Sperre, Aufrufen der Benachrichtigungsmethode usw. Durch den rationalen Einsatz der Wait- und Notify-Methoden können wir Multithreading-Probleme vermeiden und die Zuverlässigkeit und Wartbarkeit des Programms verbessern.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Objektmethoden „wait“ und „notify“ in Java korrekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!