Многопоточность

Системная синхронизация с использованием wait()/notify().

Системная синхронизация с использованием методов  `wait()`  и  `notify()`  является механизмом, предоставляемым Java для синхронизации потоков и обеспечения их взаимодействия.

Метод  `wait()`  вызывается внутри синхронизированного блока кода и заставляет текущий поток ожидать, пока другой поток не вызовет метод  `notify()`  или  `notifyAll()`  на том же объекте монитора. Когда это происходит, ожидающий поток просыпается и продолжает выполнение.

Метод  `notify()`  используется для уведомления одного из ожидающих потоков, который был приостановлен с помощью метода  `wait()` . Он выбирает один из ожидающих потоков и сообщает ему, что он может продолжить выполнение. Метод  `notifyAll()`  уведомляет все ожидающие потоки, чтобы они продолжили выполнение.

Пример использования системной синхронизации с помощью методов  `wait()`  и  `notify()` :

class Message {
    private String content;
    private boolean empty = true;

    public synchronized String read() {
        while (empty) {
            try {
                wait(); // ожидание, если сообщение пусто
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll(); // уведомление других потоков
        return content;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait(); // ожидание, если сообщение не было прочитано
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.content = message;
        notifyAll(); // уведомление других потоков
    }
}

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Message message = new Message();

        Thread writerThread = new Thread(() -> {
            String[] messages = {"Привет", "Как дела?", "Пока"};
            for (String msg : messages) {
                message.write(msg);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            message.write("Завершение");
        });

        Thread readerThread = new Thread(() -> {
            while (!message.read().equals("Завершение")) {
                System.out.println(message.read());
            }
        });

        writerThread.start();
        readerThread.start();
    }
}

В этом примере у нас есть класс  `Message` , который представляет сообщение, доступное для чтения и записи. Метод  `read()`  вызывается потоком-читателем, чтобы прочитать сообщение, и он ожидает, пока сообщение не будет записано методом  `write()` . Метод  `write()`  вызывается потоком-писателем, чтобы записать новое сообщение, и он ожидает, пока сообщение не будет прочитано методом  `read()` .

Потоки-писатель и-читатель создаются и запускаются в методе  `main()` . Поток-писатель записывает несколько сообщений со случайной задержкой, а поток-читатель читает их и выводит на экран.

Таким образом, системная синхронизация с использованием методов  `wait()`  и  `notify()`  позволяет потокам синхронизировать свои действия и обеспечивает взаимодействие между ними.