Зачем нужен wait?

Назначение метода wait() в Java для многопоточности

Метод wait() — это фундаментальный механизм межпоточного взаимодействия (inter-thread communication), который позволяет потоку добровольно освободить монитор объекта и перейти в состояние ожидания, пока другой поток не вызовет на этом же объекте методы notify() или notifyAll(). Это ключевой элемент для реализации шаблонов синхронизации, таких как Producer-Consumer (Поставщик-Потребитель).

Основные причины использования wait()

1. Эффективное использование ресурсов CPU Без wait() поток мог бы постоянно опрашивать условие в цикле (busy-waiting), что приводит к 100% загрузке ядра процессора. wait() же переводит поток в пассивное ожидание, освобождая CPU для других задач.

   // ПЛОХО: busy-waiting (нагружает CPU)
   while (!condition) {
       // Пустая трата циклов процессора
   }
   
   // ХОРОШО: использование wait()
   synchronized (lock) {
       while (!condition) {
           lock.wait(); // Поток освобождает монитор и засыпает
       }
       // Выполнение работы при выполнении условия
   }
   

2. Координация между потоками Позволяет потокам согласованно работать с общими данными. Например, поток-потребитель ждёт, пока производитель не создаст данные.

3. Предотвращение race conditions (состояния гонки) Используется вместе с synchronized для создания атомарных проверок условий. Классический паттерн:

   • Захватить монитор
   • Проверить условие в цикле while
   • Если условие не выполнено — вызвать wait()
   • После пробуждения снова проверить условие

Технические аспекты работы wait()

• Всегда вызывается внутри synchronized-блока — иначе получим IllegalMonitorStateException
• Освобождает монитор объекта на время ожидания, позволяя другим потокам войти в synchronized-секции этого объекта
• Пробуждается только после вызова notify()/notifyAll() на том же объекте
• После пробуждения поток должен перезахватить монитор, прежде чем продолжить выполнение

Пример реализации Producer-Consumer

public class SharedBuffer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int CAPACITY = 5;
    
    public void produce(int item) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == CAPACITY) {
                queue.wait(); // Ждём, пока потребитель освободит место
            }
            queue.add(item);
            queue.notifyAll(); // Уведомляем потребителей
        }
    }
    
    public Integer consume() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                queue.wait(); // Ждём, пока производитель добавит данные
            }
            Integer item = queue.poll();
            queue.notifyAll(); // Уведомляем производителей
            return item;
        }
    }
}

Важные особенности в контексте Android

1. Main Thread ограничения — на главном потоке Android нельзя вызывать wait(), так как это приведёт к блокировке UI и ANR (Application Not Responding)
2. Альтернативы в Android SDK:
   • Handler и Looper для коммуникации между потоками
   • LiveData и Flow в архитектуре Android Jetpack
   • BlockingQueue из java.util.concurrent
3. Отличие от sleep():
   • sleep() не освобождает монитор, просто приостанавливает поток на время
   • wait() освобождает монитор для других потоков

Лучшие практики использования

1. Всегда используйте wait() в цикле while для проверки условия (spurious wakeups — ложные пробуждения возможны)
2. Предпочитайте notifyAll() над notify() для более предсказуемого поведения
3. Рассмотрите использование java.util.concurrent (например, ReentrantLock с Condition) для более сложных сценариев
4. В Android используйте современные механизмы Kotlin Coroutines с Channel или Flow для асинхронных операций

Метод wait() остаётся важным низкоуровневым инструментом, понимание которого необходимо для работы с многопоточностью в Java, хотя в современных Android-приложениях чаще используются более высокоуровневые абстракции.