Используются ли методы synchronized, wait, notifyAll в реальной разработке

# Синхронизация в реальной разработке: synchronized, wait, notifyAll

Этот вопрос проверяет практическое понимание многопоточности. Ответ неоднозначный: эти методы используются, но не так часто, как думают новички.

Краткий ответ

Используются ли?

• synchronized — ДА, часто, особенно в legacy коде
• wait/notifyAll — РЕДКО, в специфических сценариях

Правильный подход в 2024:

• Предпочитай java.util.concurrent и AtomicInteger
• Избегай низкоуровневой синхронизации где возможно
• Используй CompletableFuture, ExecutorService

Где ИСПОЛЬЗУЕТСЯ synchronized

1. Legacy код и внутренние реализации JDK

// Collections
public synchronized boolean add(E e) {  // Collections.synchronizedList
    // ...
}

// HashMap (внутренняя синхронизация)
finally {
    unlock();  // ReentrantLock вместо synchronized
}

2. Простые потокобезопасные объекты

public class SimpleCounter {
    private int count = 0;
    
    // synchronized методы используются для простоты
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// Это нормально для простых случаев
// но для production часто используют AtomicInteger

3. Singleton Double-Checked Locking (редко)

// До Java 5 это был единственный способ
public class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if(instance == null) {
            synchronized(Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// В современной Java просто используй:
public enum Singleton {
    INSTANCE;
    // enum гарантирует thread-safety и singleton
}

Где РЕДКО используется wait/notifyAll

1. Классический пример: Producer-Consumer

// ❌ С wait/notifyAll (старый способ)
public class ProducerConsumer {
    private Queue<Item> queue = new LinkedList<>();
    private int maxSize = 10;
    
    public synchronized void produce(Item item) throws InterruptedException {
        while(queue.size() == maxSize) {
            wait();  // Ждёт, пока consumer возьмёт item
        }
        queue.add(item);
        notifyAll();  // Пробуждает потребителей
    }
    
    public synchronized Item consume() throws InterruptedException {
        while(queue.isEmpty()) {
            wait();  // Ждёт item
        }
        Item item = queue.poll();
        notifyAll();  // Пробуждает производителей
        return item;
    }
}

// ✅ Современный способ (BlockingQueue)
public class ProducerConsumerModern {
    private BlockingQueue<Item> queue = new LinkedBlockingQueue<>(10);
    
    public void produce(Item item) throws InterruptedException {
        queue.put(item);  // Сам ждёт если queue полная
    }
    
    public Item consume() throws InterruptedException {
        return queue.take();  // Сам ждёт если queue пуста
    }
}

2. Условные переменные (Condition, редко)

// ❌ С wait/notifyAll
public class BoundedBuffer {
    private int[] buffer;
    private int count = 0;
    private int putIndex = 0, takeIndex = 0;
    
    public synchronized void put(int x) throws InterruptedException {
        while(count == buffer.length) {
            wait();
        }
        buffer[putIndex] = x;
        if(++putIndex == buffer.length) putIndex = 0;
        ++count;
        notifyAll();
    }
    
    public synchronized int take() throws InterruptedException {
        while(count == 0) {
            wait();
        }
        int x = buffer[takeIndex];
        if(++takeIndex == buffer.length) takeIndex = 0;
        --count;
        notifyAll();
        return x;
    }
}

// ✅ Современный способ (ArrayBlockingQueue)
public class BoundedBufferModern {
    private ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(10);
    
    public void put(int x) throws InterruptedException {
        buffer.put(x);
    }
    
    public int take() throws InterruptedException {
        return buffer.take();
    }
}

РЕАЛЬНЫЕ СЦЕНАРИИ РАЗРАБОТКИ

Что используется в современном коде

// 1. CompletableFuture (async операции)
CompletableFuture.supplyAsync(() -> fetchData())
    .thenApply(data -> processData(data))
    .thenAccept(result -> System.out.println(result));

// 2. ExecutorService (управление потоками)
ExecutorService executor = Executors.newFixedThreadPool(10);
Future<Result> future = executor.submit(() -> {
    return doSomething();
});
Result result = future.get();  // Ждёт результат

// 3. BlockingQueue (thread-safe очереди)
BlockingQueue<Item> queue = new LinkedBlockingQueue<>();
queue.put(item);  // Ждёт место, если переполнена
Item item = queue.take();  // Ждёт item

// 4. ReentrantLock (вместо synchronized)
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();
}

// 5. AtomicInteger (счётчики)
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();

// 6. ConcurrentHashMap (thread-safe map)
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// 7. Volatile для флагов
private volatile boolean shutdown = false;

Примеры из реальных проектов

// Spring Framework (AsyncRestTemplate)
@Service
public class DataService {
    @Async
    public CompletableFuture<Data> fetchDataAsync() {
        Data data = fetchData();
        return CompletableFuture.completedFuture(data);
    }
}

// Kafka Consumer (используется ExecutorService)
public class KafkaConsumerService {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();
    
    public void startConsuming() {
        executor.submit(() -> {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
            // Process records
        });
    }
}

// Thread Pool (используется ExecutorService)
public class ImageProcessing {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    
    public void processImages(List<String> imagePaths) {
        for(String path : imagePaths) {
            executor.submit(() -> {
                BufferedImage image = ImageIO.read(new File(path));
                BufferedImage processed = applyFilters(image);
                ImageIO.write(processed, "jpg", new File(output));
            });
        }
    }
}

Когда ВСЁ ЕЩЁ используется wait/notifyAll

Эти методы используются, когда:

1. Работаешь с legacy кодом

// Старая кодовая база может использовать wait/notifyAll
public synchronized void processRequest() {
    while(!hasData()) {
        wait();  // legacy pattern
    }
    // process
}

1. Пишешь низкоуровневую синхронизацию

// Например, реализация собственного блокирующего буфера
public synchronized E take() throws InterruptedException {
    while(isEmpty()) {
        wait();  // Правильно использовать
    }
    E element = remove();
    notifyAll();
    return element;
}

1. Очень специфические требования к производительности

// Когда нужна максимальная оптимизация
// но это редко и требует экспертизы

Опасности wait/notifyAll

// ❌ Частая ошибка 1: if вместо while
public synchronized void problemMethod() {
    if(!ready) {  // ❌ НЕПРАВИЛЬНО
        wait();
    }
    // Spurious wakeups могут разбудить поток
    // even when condition isn't true
}

// ✅ Правильно
public synchronized void correctMethod() {
    while(!ready) {  // ✅ ПРАВИЛЬНО
        wait();
    }
}

// ❌ Ошибка 2: notify вместо notifyAll
public synchronized void badNotify() {
    notify();  // ❌ Пробуждает только ОД потока
    // Другие могут остаться ждать
}

// ✅ Правильно
public synchronized void goodNotify() {
    notifyAll();  // ✅ Пробуждает всех
    // Каждый проверит while(condition)
}

Вывод для интервью

Что сказать на собеседовании:

1. "synchronized используется, особенно в коде которому много лет"
2. "wait/notifyAll редко, предпочитаем BlockingQueue и CompletableFuture"
3. "В современной Java используем java.util.concurrent"
4. "synchronized может быть медленнее чем Lock/AtomicInteger в высоконагруженных системах"
5. "JVM оптимизирует synchronized (biased locking, lock coarsening)"
6. "В production часто используем libraries вроде Akka для многопоточности"

Рекомендации

// Порядок предпочтения:

// 1. ПЕРВЫЙ ВЫБОР: CompletableFuture
CompletableFuture.supplyAsync(() -> fetchData())
    .thenApply(this::process);

// 2. ВТОРОЙ ВЫБОР: ExecutorService
ExecutorService executor = Executors.newFixedThreadPool(cores);
Future<Result> future = executor.submit(() -> doWork());

// 3. ТРЕТИЙ ВЫБОР: BlockingQueue для буферов
BlockingQueue<Item> queue = new LinkedBlockingQueue<>();

// 4. ЧЕТВЁРТЫЙ ВЫБОР: AtomicInteger/AtomicReference
AtomicInteger counter = new AtomicInteger(0);

// 5. ПЯТЫЙ ВЫБОР: ReentrantLock (сложные сценарии)
ReentrantLock lock = new ReentrantLock();

// 6. ПОСЛЕДНИЙ ВЫБОР: synchronized
// (только если нет лучших вариантов)

// 7. ИЗБЕГАЙ: wait/notifyAll
// (используй выше указанные инструменты)