❓ Вопрос с собеса

В чём разница между ExecutorService и ForkJoinPool в Java?

Пример🔽

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class Main {
    public static void main(String[] args) {
        // Пример с ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(() -> System.out.println("Задача в ExecutorService"));
        executor.shutdown();

        // Пример с ForkJoinPool
        ForkJoinPool pool = new ForkJoinPool();
        int sum = pool.invoke(new SumTask(1, 5));
        System.out.println("Сумма: " + sum);
    }

    static class SumTask extends RecursiveTask<Integer> {
        int start, end;

        SumTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            if (end - start <= 1) {
                return start + end;
            }
            int mid = (start + end) / 2;
            SumTask left = new SumTask(start, mid);
            SumTask right = new SumTask(mid + 1, end);
            left.fork();
            return right.compute() + left.join();
        }
    }
}

Ответ🔽

ExecutorService — это абстракция для управления пулом потоков и выполнения задач (Runnable или Callable) в очереди. Он отлично подходит для стандартных многопоточных задач, где нужно управлять количеством потоков и временем жизни пула.

ForkJoinPool — это специальная реализация ExecutorService, оптимизированная для задач типа divide-and-conquer, где задачи рекурсивно делятся на подзадачи (через RecursiveTask или RecursiveAction) и выполняются с помощью алгоритма "work-stealing".

📌 Если задачи независимые и нет сложного деления — хватит обычного ExecutorService. Если нужна параллельная рекурсия и максимальная загрузка процессоров — лучше ForkJoinPool.

➡️ Easy Java | #Собес

➡️ Easy Java | #Викторина

👩‍💻 Что такое Phaser в Java и зачем он нужен?

Phaser — это гибкий синхронизатор из пакета java.util.concurrent, который работает как усовершенствованный вариант CyclicBarrier и CountDownLatch. Он позволяет потокам синхронизироваться по фазам (этапам) выполнения задачи.

Главное отличие: количество участников (parties) можно динамически регистрировать и снимать с регистрации, что делает Phaser более универсальным.

• Поддерживает несколько фаз (циклов синхронизации)
• Позволяет динамически добавлять/удалять потоки
• Можно строить сложные сценарии синхронизации

⚡️ Пример:

import java.util.concurrent.Phaser;

public class Main {
    public static void main(String[] args) {
        Phaser phaser = new Phaser(3); // 3 потока-участника

        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " — фаза 1");
            phaser.arriveAndAwaitAdvance(); // ждём остальных

            System.out.println(Thread.currentThread().getName() + " — фаза 2");
            phaser.arriveAndAwaitAdvance(); // ждём остальных
        };

        new Thread(task, "Поток 1").start();
        new Thread(task, "Поток 2").start();
        new Thread(task, "Поток 3").start();
    }
}

👀 Phaser особенно полезен, когда у задачи есть несколько этапов, и все потоки должны переходить к следующему этапу только синхронно — например, в симуляциях, распределённых вычислениях или пошаговых моделях.

➡️ Easy Java | #Теория

➡️ Easy Java | #Викторина

❓ Вопрос с собеса

Что такое CompletableFuture в Java и чем он отличается от Future?

Пример🔽

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future =
                CompletableFuture.supplyAsync(() -> "Hello")
                                 .thenApply(str -> str + ", world!")
                                 .thenApply(String::toUpperCase);

        System.out.println(future.get()); // ➔ HELLO, WORLD!
    }
}

Ответ🔽

Future позволяет запустить задачу в отдельном потоке и получить результат, но работать с ним неудобно: нет удобных методов для цепочек, обработки ошибок и асинхронных комбинаций.

CompletableFuture — это расширение Future, которое:
— поддерживает асинхронные цепочки вычислений (thenApply, thenAccept, thenCompose)
— умеет комбинировать несколько задач (allOf, anyOf)
— позволяет удобно обрабатывать исключения (exceptionally)
— работает в стиле промисов из JavaScript

📌 Future подходит для простых асинхронных вычислений, а CompletableFuture — для сложных асинхронных цепочек и реактивного программирования.

➡️ Easy Java | #Собес

➡️ Easy Java | #Викторина

👩‍💻 Что такое Semaphore в Java и зачем он нужен?

Semaphore — это синхронизатор из пакета java.util.concurrent, который ограничивает количество потоков, одновременно обращающихся к ресурсу. Он работает как счётчик разрешений (permits): поток должен получить разрешение, чтобы продолжить работу, и обязан его освободить после завершения.

Это удобно, когда ресурс ограничен — например, доступ к базе, пулу соединений или ограниченному количеству файлов.

• Контролирует доступ к общим ресурсам
• Поддерживает справедливый режим (fair) для очередности
• Помогает избежать перегрузки системных ресурсов

⚡️ Пример:

import java.util.concurrent.Semaphore;

public class Main {
    private static final Semaphore semaphore = new Semaphore(2); // максимум 2 потока одновременно

    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " получил доступ");
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " освобождает доступ");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        };

        for (int i = 1; i <= 5; i++) {
            new Thread(task, "Поток " + i).start();
        }
    }
}

👀 Semaphore особенно полезен в системах, где необходимо ограничить количество одновременных операций — например, при обращении к API с лимитами, управлении пулом соединений или ограничении нагрузки на сервис.

➡️ Easy Java | #Теория

📖 Как заменить GitHub Copilot на полностью офлайн‑Continue Plugin

Покажу, как приручить Continue вместо Copilot: подключу локальную LLM, всё без сети — файлы не утекут. Настройка в IDE+LM Studio, фишки, грабли, бенч, выводы.

⛓ Читать статью

➡️ Easy Java | #Статья

➡️ Easy Java | #Викторина

❓ Вопрос с собеса

Что такое ConcurrentHashMap в Java и чем он отличается от HashMap?

Пример🔽

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new ConcurrentHashMap<>();

        map.put("A", 1);
        map.put("B", 2);

        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            map.put("C", 3); // не вызовет ConcurrentModificationException
        });

        System.out.println(map);
    }
}

Ответ🔽

HashMap не является потокобезопасной: если несколько потоков одновременно изменяют её, возможны ошибки и ConcurrentModificationException.

ConcurrentHashMap — это потокобезопасная альтернатива, которая:
— позволяет одновременно читать и писать без полной блокировки всей карты
— делит данные на сегменты для повышения производительности
— гарантирует согласованность данных при многопоточном доступе

📌 Если работа только в одном потоке — можно использовать обычный HashMap. Если данные разделяются между потоками — правильнее брать ConcurrentHashMap.

➡️ Easy Java | #Собес

➡️ Easy Java | #Викторина

👩‍💻 Что такое Exchanger в Java и зачем он нужен?

Exchanger — это синхронизатор из пакета java.util.concurrent, который позволяет двум потокам обмениваться данными в точке встречи. Каждый поток вызывает метод exchange(), и когда оба потока доходят до этой точки, они обмениваются переданными объектами.

Это удобно, когда два потока должны координировать свои действия, передавая результаты вычислений друг другу.

• Позволяет безопасно обмениваться объектами между потоками
• Подходит для реализации producer-consumer моделей
• Удобен для синхронных этапов вычислений

⚡️ Пример:

import java.util.concurrent.Exchanger;

public class Main {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        Runnable producer = () -> {
            try {
                String data = "Данные от Producer";
                System.out.println("Producer отправил: " + data);
                String response = exchanger.exchange(data);
                System.out.println("Producer получил: " + response);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        Runnable consumer = () -> {
            try {
                String data = "Ответ от Consumer";
                System.out.println("Consumer отправил: " + data);
                String received = exchanger.exchange(data);
                System.out.println("Consumer получил: " + received);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

👀 Exchanger особенно полезен, когда два потока выполняют разные задачи и должны регулярно обмениваться результатами — например, генератор данных и обработчик, или два этапа сложного расчёта.

➡️ Easy Java | #Теория

📖 Хватит терять время! Ускоряем сборку с помощью Spring Test Profiler

Покажу: Spring Test Profiler находит лишние перезапуски контекста и рассинхрон конфигов; унифицирую окружение, чиню кэш и ускоряю интеграц-тесты. Будет чек-лист.

⛓ Читать статью

➡️ Easy Java | #Статья