Какие знаешь механизмы многопоточности?

Механизмы многопоточности в Java

Многопоточность — это один из ключевых механизмов Java, позволяющих выполнять несколько задач параллельно. Рассмотрю основные механизмы синхронизации и управления потоками.

1. Потоки и их создание

В Java потоки создаются двумя основными способами:

Наследование от Thread:

class MyThread extends Thread {
    public void run() {
        System.out.println("Поток выполняется");
    }
}
MyThread thread = new MyThread();
thread.start();

Реализация Runnable:

Runnable task = () -> System.out.println("Поток выполняется");
Thread thread = new Thread(task);
thread.start();

Реализация Runnable считается предпочтительным способом, так как Java не поддерживает множественное наследование.

2. Синхронизация с ключевым словом synchronized

Синхронизированные методы:

public synchronized void criticalSection() {
    // Доступ к общим данным
    counter++;
}

Синхронизированные блоки:

public void method() {
    synchronized(this) {
        // Только один поток может выполнять код в блоке
        counter++;
    }
}

Синхронизация предотвращает race conditions и обеспечивает видимость изменений между потоками через встроенный механизм happens-before отношений.

3. Volatile переменные

volatile гарантирует видимость изменений между потоками без блокировки:

private volatile boolean flag = false;

Отличается от synchronized тем, что не предотвращает race conditions, но гарантирует видимость последних значений.

4. Механизмы ожидания и уведомления

wait(), notify(), notifyAll():

synchronized void waitForCondition() throws InterruptedException {
    while (!condition) {
        this.wait(); // Поток ждёт уведомления
    }
}

synchronized void signalCondition() {
    condition = true;
    this.notifyAll(); // Пробуждает все ждущие потоки
}

Эти методы работают только внутри синхронизированных контекстов и используются для координации потоков.

5. Lock и ReentrantLock

java.util.concurrent предоставляет более гибкие механизмы:

Lock lock = new ReentrantLock();
try {
    lock.lock();
    // Критическая секция
} finally {
    lock.unlock();
}

ReentrantLock позволяет:

• Переиспользовать блокировку одним потоком
• Использовать условные переменные (Condition)
• Прерывать ожидание
• Устанавливать таймауты

6. Atomic классы

Для простых операций над примитивами используются атомарные переменные:

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // Атомарное увеличение
counter.compareAndSet(expected, newValue); // CAS операция

7. Thread Pool и ExecutorService

Управление потоками через пулы:

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> {
    // Задача выполняется в пуле потоков
});
executor.shutdown();

Пулы потоков эффективнее, чем создание новых потоков для каждой задачи.

8. Collections для потокобезопасности

Для работы с коллекциями в многопоточной среде используются:

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> map = new ConcurrentHashMap<>();
Queue<String> queue = new ConcurrentLinkedQueue<>();

ConcurrentHashMap особенно полезна, так как использует сегментированное блокирование вместо синхронизации всей таблицы.

9. Барьеры и Latches

CountDownLatch для ожидания нескольких потоков:

CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    executor.submit(() -> {
        // Работа
        latch.countDown();
    });
}
latch.await(); // Ждём, пока счётчик станет 0

CyclicBarrier для синхронизации в определённых точках:

CyclicBarrier barrier = new CyclicBarrier(3);
barrier.await(); // Ждём, пока все потоки достигнут этой точки

10. Состояния потоков

Поток может находиться в следующих состояниях:

• NEW — создан, но не запущен
• RUNNABLE — готов к выполнению или выполняется
• BLOCKED — ждёт блокировки
• WAITING — ждёт уведомления от другого потока
• TIMED_WAITING — ждёт с таймаутом
• TERMINATED — завершил работу

Заключение

Выбор механизма многопоточности зависит от задачи:

• synchronized — простые случаи с критическими секциями
• volatile — видимость без синхронизации
• ReentrantLock — сложные сценарии с условиями
• Atomic классы — простые атомарные операции
• ExecutorService — управление пулами потоков
• Concurrent Collections — потокобезопасные коллекции

Правильное использование этих механизмов критично для создания надёжных и производительных многопоточных приложений.