Lernen Sie die Funktionen und Anwendungen der Objektmethoden „wait' und „notify' in Java kennen

Objektmethoden in Java verstehen: die Rolle und Verwendung von Warten und Benachrichtigen

In Java sind Objektmethoden ein wichtiges Werkzeug für die Implementierung der gleichzeitigen Programmierung. Unter diesen sind Warten und Benachrichtigen zwei häufig verwendete Methoden, mit denen Thread-Warte- und Aufweckvorgänge implementiert werden. In diesem Artikel werden diese beiden Methoden ausführlich vorgestellt und einige spezifische Codebeispiele bereitgestellt. Die

wait-Methode ist eine in der Object-Klasse definierte Methode. Sie wird verwendet, um den aktuellen Thread in einen Wartezustand zu versetzen, bis andere Threads die notify- oder notifyAll-Methode desselben Objekts aufrufen, um ihn aufzuwecken. Bevor die Wartemethode aufgerufen wird, muss der Thread zunächst die Monitorsperre des Objekts erhalten. Die Wartemethode hat zwei überladene Formen:

1. wait(): lässt den aktuellen Thread warten, bis andere Threads ihn aufwecken.
2. wait(long timeout): Lässt den aktuellen Thread für die angegebene Anzahl von Millisekunden warten oder bis ein anderer Thread ihn aufweckt.

Das Folgende ist ein Beispielcode, der die Wartemethode verwendet, um das Producer-Consumer-Modell zu implementieren:

public class ProducerConsumer {
    private final Object lock = new Object();
    private List<String> buffer = new ArrayList<>();
    private int bufferSize = 10;
    
    public void produce() throws InterruptedException {
        synchronized (lock) {
            // 判断缓冲区是否已满
            while (buffer.size() == bufferSize) {
                lock.wait(); // 等待消费者消费
            }
            // 生产物品到缓冲区
            buffer.add("Item");
            System.out.println("生产者生产一个物品，缓冲区大小：" + buffer.size());
            // 唤醒等待的消费者线程
            lock.notifyAll();
        }
    }
    
    public void consume() throws InterruptedException {
        synchronized (lock) {
            // 判断缓冲区是否为空
            while (buffer.isEmpty()) {
                lock.wait(); // 等待生产者生产
            }
            // 从缓冲区消费物品
            String item = buffer.remove(0);
            System.out.println("消费者消费一个物品，缓冲区大小：" + buffer.size());
            // 唤醒等待的生产者线程
            lock.notifyAll();
        }
    }
}

Im obigen Code verwendet der Produzent die Wartemethode, um sich vor der Produktion in einen Wartezustand zu versetzen, bis der Puffer voll ist ; Der Verbraucher verwendet die Wartemethode, um sich vor dem Verbrauch in einen Wartezustand zu versetzen, bis der Puffer nicht leer ist. Wenn ein Produzent einen Artikel produziert oder ein Verbraucher einen Artikel konsumiert, wird die notifyAll-Methode des Objekts aufgerufen, um den wartenden Thread aufzuwecken. Die

notify-Methode ist ebenfalls eine in der Object-Klasse definierte Methode. Sie wird verwendet, um einen Thread zu aktivieren, der auf dasselbe Objekt wartet. Im Gegensatz zur notifyAll-Methode kann die notify-Methode nur einen der Threads aktivieren. Das Folgende ist ein Beispiel für die Verwendung der Benachrichtigungsmethode:

public class ThreadMonitor {
    private final Object lock = new Object();
    
    public void performTask() throws InterruptedException {
        synchronized (lock) {
            System.out.println("线程" + Thread.currentThread().getId() + "开始执行任务");
            lock.wait(); // 等待唤醒
            System.out.println("线程" + Thread.currentThread().getId() + "继续执行任务");
        }
    }
    
    public void wakeUpThread() {
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
}

Im obigen Code versetzt die performTask-Methode den Thread in einen Wartezustand, bis andere Threads die wakeUpThread-Methode aufrufen, um ihn aufzuwecken. Die Methode wakeUpThread verwendet die Methode notify, um einen wartenden Thread aufzuwecken.

Es ist zu beachten, dass Sie bei Verwendung der Wait- und Notify-Methoden zunächst die Monitorsperre des Objekts erhalten müssen, dh es in einem synchronisierten Codeblock oder einer synchronisierten Methode verwenden müssen.

Zusammenfassend lässt sich sagen, dass Warten und Benachrichtigen wichtige Methoden in Java sind, um die Kommunikation zwischen Threads zu realisieren. Sie können Thread-Warte- und Weckvorgänge implementieren und werden verwendet, um die Ausführungssequenz mehrerer Threads und den Zugriff auf gemeinsam genutzte Ressourcen zu koordinieren. Die in diesem Artikel bereitgestellten Codebeispiele können den Lesern helfen, die Verwendung dieser beiden Methoden besser zu verstehen. Durch die ordnungsgemäße Verwendung der Warte- und Benachrichtigungsmethoden können wir sicherere und effizientere Multithread-Programme schreiben.

Das obige ist der detaillierte Inhalt vonLernen Sie die Funktionen und Anwendungen der Objektmethoden „wait' und „notify' in Java kennen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!