Перейти на PRO

Опишите ваш опыт работы с многопоточностью в Java

Тип вопроса: Java Core Вероятность: 10% Категория: Java Разработчик

Ответ

Опыт охватывает низкоуровневые и высокоуровневые API многопоточности:

  • Создание потоков: Thread, Runnable, Callable.
  • Управление пулами: ExecutorService, ForkJoinPool.
  • Асинхронные вычисления: Future, CompletableFuture.
  • Синхронизация: synchronized, ReentrantLock, ReadWriteLock, Semaphore.
  • Потокобезопасные коллекции: ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue.
  • Атомарные операции: volatile, AtomicInteger и другие классы из java.util.concurrent.atomic.

Ключевые решаемые проблемы: Race condition, deadlock, livelock, starvation.

Пример использования ExecutorService:

// Создание пула из 4 потоков
ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<Integer>> futures = new ArrayList<>();

// Отправка задач на выполнение
for (int i = 0; i < 10; i++) {
    futures.add(executor.submit(() -> {
        // Имитация работы задачи
        return ThreadLocalRandom.current().nextInt(100);
    }));
}

// Получение результатов
for (Future<Integer> f : futures) {
    try {
        System.out.println("Результат: " + f.get()); // get() блокирует поток
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

// Обязательное завершение работы пула
executor.shutdown();

Почему ExecutorService предпочтительнее new Thread()? Эффективное управление ресурсами (переиспользование потоков), контроль над количеством одновременно выполняемых задач.

Дополнительно: Опыт с CompletableFuture для построения асинхронных цепочек и комбинирования результатов, а также с ForkJoinPool для рекурсивного параллелизма (например, обход деревьев).

Ответ 18+ 🔞

Да ты посмотри, какой список, ёпта! Прямо как в аптеке — от головной боли синхронизации до слабительного для пулов потоков. Ну что, разбираем эту банду гопников из java.util.concurrent?

Низкоуровневые деды и высокоуровневые пацаны:

  • Старая школа, в натуре: Thread, Runnable, Callable. Это как вручную коробку передач переключать — мощно, но можно и движок в пизду угробить.
  • Организованная бригада: ExecutorService, ForkJoinPool. Тут уже тебе не самому пацанов с подворотни нанимать, а целый офис с менеджером, который распределяет задачи. Цивилизация, блядь.
  • Обещания, которые не всегда выполняются: Future, CompletableFuture. Дал задание — получи талончик. Потом пришёл — а тебе либо результат, либо морду, если эксепшен вылез. CompletableFuture — это вообще хитрая жопа, которая позволяет эти талончики в цепочки собирать, будто из кубиков Лего.
  • Разборки за ресурсы: synchronized, ReentrantLock, ReadWriteLock, Semaphore. Это чтобы два потока не подрались, как два барана, из-за одной переменной. Кто первый монитор схватил — тот и царь горы. Семафор — это как пропуск в закрытый клуб: только N штук, остальные ждут у входа, как лохи.
  • Потокобезопасные тусовки: ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue. Заходишь, берёшь что надо, не толкаясь. В BlockingQueue вообще красота: один поток кладёт, другой забирает, и никто никого не дёргает, если очередь пустая или полная — просто спят, сука, мирно.
  • Атомарные операции: volatile, AtomicInteger и братва. Это когда нужно не просто прочитать-записать, а сделать это так, чтобы в самый ответственный момент другой поток не влез со своим грязным указательным пальцем. Чистая работа, без шума и пыли.

А чего мы, собственно, боимся? Race condition (гонки, где побеждает самый быстрый и непредсказуемый), deadlock (взаимный облом, когда все ждут друг друга и все в жопе), livelock (суетливая беготня без результата, как мартышлюшка) и starvation (когда какому-то бедолаге вечно не хватает).

Вот, смотри, как с пулом работать не по-детски:

// Создаём пул на 4 потока. Не больше, чтоб комп не взвыл.
ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<Integer>> futures = new ArrayList<>();

// Кидаем в пул 10 задач. Он сам разберётся, кому что делать.
for (int i = 0; i < 10; i++) {
    futures.add(executor.submit(() -> {
        // Задача делает вид, что работает
        return ThreadLocalRandom.current().nextInt(100);
    }));
}

// Теперь собираем урожай. get() — это ждём, пока задача не выплюнет результат.
for (Future<Integer> f : futures) {
    try {
        System.out.println("Результат: " + f.get()); // Терпеливо стоим в очереди
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace(); // Ага, щас, конечно, "ошибка"
    }
}

// ВСЕГДА, блядь, выключай пул! Иначе потоки так и останутся висеть призраками.
executor.shutdown();

А че не new Thread()? Да потому что это как каждый раз новую тачку покупать, чтобы до магазина съездить. Нафига? ExecutorService — это каршеринг, ебать. Потоки переиспользуются, очередь задач есть, контроль полный. Экономия и порядок.

Ну и вишенка: CompletableFuture — это когда тебе нужно не просто дождаться одного результата, а построить целую асинхронную схему: выполни это, потом обработай то, а потом скомбинируй оба результата и плюнь в потолок. А ForkJoinPool — для рекурсивных делов, типа обхода дерева, где задачу можно нахуй разбить на кучу мелких, а потом обратно собрать. Красота, да и только.

© ХакСобесов, 2026
support@hacksobesov.com