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

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

notifyAll() — это метод класса Object в Java, который используется для пробуждения всех потоков, ожидающих на мониторе данного объекта. Он является ключевым инструментом для реализации межпоточного взаимодействия в многопоточных приложениях на Android и в Java в целом.

Основной принцип работы

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

public class SharedResource {
    private boolean dataReady = false;
    
    public synchronized void produce() {
        // Производим данные
        dataReady = true;
        // Пробуждаем все ожидающие потоки
        notifyAll();
    }
    
    public synchronized void consume() {
        while (!dataReady) {
            try {
                // Ожидаем, пока данные не будут готовы
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        // Потребляем данные
        dataReady = false;
    }
}

Ключевые особенности notifyAll():

1. Пробуждение всех ожидающих потоков — в отличие от notify(), который будит только один случайный поток, notifyAll() гарантирует, что все потоки, вызвавшие wait() на этом объекте, получат уведомление.

2. Конкуренция за монитор — после вызова notifyAll() все пробудившиеся потоки начинают конкурировать за захват монитора объекта. Только один поток может захватить монитор в каждый момент времени, остальные будут ждать в состоянии BLOCKED.

3. Использование в цикле while — стандартный паттерн использования всегда включает проверку условия в цикле:

   synchronized (lock) {
       while (!condition) {
           lock.wait();
       }
       // Выполнение работы
   }
   

   Это защищает от ложных пробуждений (spurious wakeups), которые могут происходить даже без вызова notify() или notifyAll().

Разница между notify() и notifyAll()

• notify() — будит один случайный поток. Эффективнее по производительности, но опаснее:

  • Может привести к голоданию потока, если его постоянно не выбирают
  • Не подходит для ситуаций, где все потоки должны реагировать на изменение состояния

• notifyAll() — будит все потоки. Более безопасный подход:

  • Гарантирует, что нужный поток обязательно получит уведомление
  • Все потоки перепроверяют условие, что обеспечивает корректность логики
  • Рекомендуется к использованию в большинстве случаев на Android

Практическое применение в Android

На Android notifyAll() особенно важен при работе с:

• Фоновыми задачами — когда несколько компонентов ждут завершения операции
• Очередями сообщений — для синхронизации доступа к shared ресурсам
• Кэшированием данных — при ожидании загрузки данных из сети или БД

// Пример на Kotlin для Android
class DataLoader {
    private val lock = Object()
    private var data: Result? = null
    
    fun loadData(): Result {
        synchronized(lock) {
            while (data == null) {
                lock.wait()
            }
            return data!!
        }
    }
    
    fun onDataLoaded(result: Result) {
        synchronized(lock) {
            data = result
            lock.notifyAll() // Все ожидающие потоки получат данные
        }
    }
}

Важные предосторожности

1. Синхронизированный контекст — notifyAll() должен вызываться только из синхронизированного блока или метода, иначе будет выброшено IllegalMonitorStateException.

2. Производительность — массовое пробуждение потоков может создать нагрузку на планировщик. Если нужно будить только один поток — используйте notify().

3. Альтернативы в современных Android-приложениях:

   • Корутины с Channel и Flow
   • RxJava с субъектами
   • LiveData и StateFlow с их внутренними механизмами синхронизации

Заключение

notifyAll() — это надежный, хотя и не всегда самый эффективный, способ координации между потоками. В современной Android-(и не только Android)-разработке его использование постепенно сокращается в пользу более высокоуровневых абстракций, но понимание этого метода остается критически важным для глубокого понимания многопоточности в Java и Kotlin. При его использовании всегда помните о необходимости синхронизации, проверке условий в цикле и учитывайте возможное влияние на производительность.