Что делает метод notify?

Общее предназначение метода notify()

Метод notify() — это один из ключевых механизмов межпоточной синхронизации (inter-thread communication) в Java. Он используется для «пробуждения» одного потока, который находится в состоянии ожидания (вызвав метод wait()) на том же мониторе объекта (object's monitor).

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

Принцип работы и связь с wait() и монитором

Чтобы понять notify(), нужно рассматривать его в неразрывной связке с методами wait(), notifyAll() и концепцией монитора.

1. Монитор объекта: Каждый объект в Java имеет связанный с ним «монитор» — внутренний механизм блокировки. Когда поток входит в synchronized метод или блок, он «захватывает» монитор этого объекта.
2. wait(): Поток, владеющий монитором, может добровольно освободить его и перейти в состояние ожидания, вызвав wait(). Это делается, например, когда условие для работы потока не выполняется (например, буфер пуст). При вызове wait() поток обязательно должен владеть монитором (находиться внутри synchronized-блока для этого объекта).
3. notify(): Другой поток, изменив общее состояние (например, добавив элемент в буфер), вызывает notify() для того же объекта, также обязательно владея его монитором. Этот вызов будит один произвольно выбранный поток из числа ожидающих на этом мониторе.
4. Продолжение работы: «Разбуженный» поток не запускается мгновенно. Сначала он должен перезахватить монитор объекта (который сейчас, скорее всего, удерживает поток, вызвавший notify()). Как только synchronized-блок, из которого был вызван notify(), завершится и монитор освободится, один из разбуженных потоков получит монитор обратно и продолжит выполнение с того места, где он остановился после wait().

Ключевые особенности и правила использования

• Требование монитора: И wait(), и notify() должны вызываться только внутри synchronized-блока или метода, который синхронизирован по тому же объекту (this или явному объекту-монитору).
• Пробуждение одного потока: notify() будит только один случайный поток из очереди ожидания. Если ожидающих потоков несколько, остальные так и останутся ждать.
• Альтернатива — notifyAll(): Метод notifyAll() пробуждает все потоки, ожидающие на данном мониторе. Они по очереди попытаются перезахватить монитор и продолжить работу. notifyAll() используется чаще, так как он безопаснее и предотвращает ситуацию «потерянного уведомления» (lost wake-up), особенно когда условия ожидания у потоков могут различаться.
• Отсутствие гарантий: Нет гарантий, какой именно поток будет разбужен notify(). Это зависит от реализации JVM.
• Унаследован от Object: Методы wait(), notify(), notifyAll() являются final и объявлены в классе Object, так как механизм монитора есть у каждого объекта.

Пример использования (Producer-Consumer)

Рассмотрим классический пример с ограниченным буфером (очередью).

import java.util.LinkedList;
import java.util.Queue;

class SharedBuffer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int CAPACITY = 5;

    public synchronized void produce(int item) throws InterruptedException {
        // Ждем, пока есть место. Всегда используем wait() в цикле!
        while (queue.size() == CAPACITY) {
            wait(); // Освобождаем монитор и ждем
        }
        queue.add(item);
        System.out.println("Produced: " + item);
        // Уведомляем один ожидающий поток-потребитель (или производитель, если буфер был пуст)
        notify();
        // В реальном коде здесь часто используют notifyAll() для надежности
    }

    public synchronized int consume() throws InterruptedException {
        // Ждем, пока есть что потребить
        while (queue.isEmpty()) {
            wait();
        }
        int item = queue.poll();
        System.out.println("Consumed: " + item);
        // Уведомляем один ожидающий поток-производитель (или потребитель, если буфер был полон)
        notify();
        return item;
    }
}

Важные нюансы в примере:

1. Цикл while вместо if: Ожидание всегда должно проверяться в цикле. Поток может быть разбужен не только по notify(), но и из-за ложного пробуждения (spurious wakeup) — особенности некоторых операционных систем. Цикл гарантирует повторную проверку условия после пробуждения.
2. Синхронизация: Оба метода synchronized, значит, они используют монитор объекта SharedBuffer (this).

Применение в Android (Context)

В Android, особенно в компонентах с жизненным циклом (например, Activity или Service), прямое использование wait()/notify() встречается редко. Для фоновых задач и синхронизации предпочтительнее использовать более высокоуровневые API:

• Handler, Looper и HandlerThread для коммуникации между потоками.
• AsyncTask (устарел).
• Корутины Kotlin с Mutex и каналами.
• ExecutorService из java.util.concurrent.
• LiveData или Flow в архитектуре Android Jetpack.

Однако понимание notify() и wait() остается критически важным для глубокого понимания многопоточности в Java, которая лежит в основе всех этих высокоуровневых инструментов. Эти методы — фундаментальный низкоуровневый примитив, на котором построены многие более сложные механизмы синхронизации (такие как Semaphore, CountDownLatch, блокирующие очереди).