❓ Гарантирует ли ExecutorService корректное завершение всех задач, если вызвать shutdown()?

Нет, shutdown() не гарантирует корректное завершение всех задач.

🔹 shutdown() делает следующее:

— запрещает принимать новые задачи;
— позволяет завершиться уже запущенным и ожидающим задачам;
— возвращает управление сразу же, не дожидаясь завершения.

🐸 Библиотека собеса по Java

#concurrency

❓ Что такое false sharing в многопоточности Java и как его избежать?

False sharing возникает, когда разные потоки обновляют разные переменные, находящиеся в одной кэш-линии CPU.
Несмотря на отсутствие логической связи, процессор вынужден постоянно инвалидировать кэш, создавая задержки.

Последствия: высокая латентность, падение пропускной способности, резкое ухудшение производительности в hot-paths.

Как избежать:

• Разнести горячие поля по разным кэш-линиям → использовать @Contended (JDK 8+, требует -XX:-RestrictContended).
• Заполнять структуру “паддингом” вручную.
• Перепроектировать алгоритм, чтобы снизить частоту записи.

🐸 Библиотека собеса по Java

#concurrency

❓ Чем отличается процесс от потока?

🔹 Процесс — это отдельная программа, выполняющаяся в своей выделенной области памяти. У каждого процесса есть собственное адресное пространство, и он изолирован от других процессов.

Взаимодействие между процессами требует механизмов межпроцессного взаимодействия (IPC), таких как сокеты, каналы или общая память. Это делает процессы более независимыми, но обмен данными между ними — более сложным и ресурсозатратным.

🔹 Поток — это "легковесная" единица выполнения, которая работает в рамках одного процесса и использует общую память этого процесса.

В Java потоки одного процесса могут совместно использовать объекты и переменные, что значительно упрощает взаимодействие между ними по сравнению с процессами. Однако такая общая память влечет за собой риски, такие как состояния гонок и необходимость синхронизации, чтобы избежать конфликтов при одновременном доступе к ресурсам.

🐸 Библиотека собеса по Java

#concurrency

❓ Почему нельзя использовать ArrayList в многопоточной среде?

❌

Если два потока одновременно добавят элементы, они создадут ситуацию, где список существует в двух состояниях одновременно (квантовая суперпозиция данных).

✔️

ArrayList не thread-safe, потому что все операции не синхронизированы. При concurrent доступе возникают три основные проблемы:

1. Race condition при модификации.
2. ConcurrentModificationException.
3. Нарушение инвариантов (самое опасное).

🐸 Библиотека собеса по Java

#concurrency

❓ Какие существуют состояния потока?

Thread может находиться в одном из следующих состояний (Thread.State):

1️⃣ NEW — поток создан, но еще не запущен.
2️⃣ RUNNABLE — поток готов к выполнению, но может ожидать процессорное время.
3️⃣ BLOCKED — поток ждет освобождения монитора для входа в synchronized блок.
4️⃣ WAITING — поток ожидает сигнал без тайм-аута.
5️⃣ TIMED_WAITING — поток ожидает, но с ограничением по времени.
6️⃣ TERMINATED — поток завершил выполнение.

🐸 Библиотека собеса по Java

#concurrency #лучшее2025

❓ Что такое Happens-Before отношение?

Happens-Before — это гарантия видимости изменений между потоками в Java Memory Model.

Если действие A happens-before действия B, то все изменения памяти, сделанные в A, будут видны в B.

Примеры правил:
— разблокировка монитора happens-before следующей блокировки того же монитора.
— запись в volatile поле happens-before чтения из него.
— завершение потока happens-before join() на этом потоке.

Это фундаментальная концепция для понимания многопоточности в Java.

🐸 Библиотека собеса по Java

#concurrency

❓ В чём разница между CopyOnWriteArrayList и Collections.synchronizedList()?

CopyOnWriteArrayList создаёт копию массива при каждой модификации. Чтение не блокируется вообще, подходит для случаев, когда чтений много, а записей мало.

Collections.synchronizedList() оборачивает обычный List и синхронизирует каждый метод через монитор. Все операции (и чтение, и запись) блокируются.

🐸 Библиотека собеса по Java

#concurrency

❓ Чем отличается invokeAll() от submit() в ExecutorService?

→ submit() отправляет одну задачу и сразу возвращает Future. Задача выполняется асинхронно.

→ invokeAll() принимает коллекцию задач и блокирует поток до завершения всех задач. Возвращает список Future только когда все задачи выполнены или вышел таймаут.

🐸 Библиотека собеса по Java

#concurrency

❓ Что такое Race Condition?

Race Condition — это ситуация, когда результат работы программы зависит от порядка выполнения потоков.

Классический пример — инкремент:

// Два потока выполняют:
counter++;  // read-modify-write

// Без синхронизации:
// Поток 1: читает 0
// Поток 2: читает 0
// Поток 1: пишет 1
// Поток 2: пишет 1
// Итого: 1 вместо 2

Решения: synchronized, AtomicInteger, Lock, volatile (только для простых операций).

🐸 Библиотека собеса по Java

#concurrency

❓ Что такое Thread Pool?

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

Основная цель — минимизация накладных расходов на создание и уничтожение потоков. Вместо того чтобы создавать новый поток для каждой задачи, задачи передаются уже существующим потокам в пуле.

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

🐸 Библиотека собеса по Java

#concurrency

❓ В чем разница между параллелизмом и многопоточностью?

Многопоточность — это способность программы выполнять несколько потоков , где каждый поток может выполняться независимо, но не обязательно одновременно. Потоки могут переключаться между собой, создавая иллюзию одновременности, однако они могут работать на одном ядре процессора.

Параллелизм, с другой стороны, — это выполнение нескольких задач одновременно, обычно на разных процессорах или ядрах. В контексте параллелизма, задачи действительно выполняются одновременно.

🐸 Библиотека собеса по Java

#concurrency

❓ Гарантирует ли ExecutorService корректное завершение всех задач, если вызвать shutdown()?

Нет, shutdown() не гарантирует корректное завершение всех задач.

🔹 shutdown() делает следующее:

— запрещает принимать новые задачи;
— позволяет завершиться уже запущенным и ожидающим задачам;
— возвращает управление сразу же, не дожидаясь завершения.

🐸 Библиотека собеса по Java

#concurrency

❓ Объясните happens-before отношение в Java Memory Model?

happens-before — это гарантированный порядок между операциями, который определяет, что эффект одной операции виден другой. Если операция A happens-before операции B, то все изменения, сделанные в A, будут видны к моменту B.

Примеры гарантий happens-before: запись в volatile поле и последующее чтение того же поля; блокировки synchronized; Thread.start() и Thread.join().

Без гарантии happens-before два потока могут видеть неверные или устаревшие значения: один поток записал в поле, другой не увидит это изменение.

🐸 Библиотека собеса по Java

#concurrency

❓ Что такое Virtual Threads, какие подводные камни при их включении?

Virtual Threads (Project Loom) — это легковесные потоки JVM, которые не привязаны 1-к-1 к OS-потокам.

Spring Boot 3.2+ поддерживает их из коробки — достаточно одной строчки:

propertiesspring.threads.virtual.enabled=true

Это переключает Tomcat, @Async, @Scheduled и TaskExecutor на виртуальные потоки.

Что даёт: при blocking I/O (JDBC, HTTP-клиенты, файлы) виртуальные потоки освобождают carrier thread во время ожидания. Пропускная способность растёт без реактивного кода.

🔹 Подводные камни

▪️ Pinning — до Java 24 вход в synchronized блок или нативный код, и поток "пиннится" к carrier thread и блокирует его.

▪️ ThreadLocal — если у каждого виртуального потока свой ThreadLocal с тяжёлым объектом — heap быстро кончается.

▪️ Пулы соединений — виртуальных потоков может быть тысячи, и если каждый держит соединение из пула (HikariCP), пул быстро исчерпается.

▪️ CPU-bound задачи — Virtual Threads тут не помогут и могут даже навредить. Для счёта — обычный ForkJoinPool.

Вывод: включается легко, но нужно понимать, где узкое место. Не серебряная пуля — это инструмент для I/O-bound нагрузки.

🐸 Библиотека собеса по Java

#concurrency

❓ Какие уровни изоляции транзакций существуют?

Существует 4 основных уровня изоляции транзакций, каждый из которых определяет степень видимости данных, изменённых в одной транзакции, для других транзакций:

🔹 READ UNCOMMITTED

Наименьший уровень изоляции. Другие транзакции могут читать изменения, которые ещё не были зафиксированы (не коммитнуты). Это может привести к грязным чтениям.

🔹 READ COMMITTED

Транзакция видит только те изменения, которые были зафиксированы другими транзакциями. Это предотвращает грязные чтения, но допускает неповторяемые чтения.

🔹 REPEATABLE READ

Гарантирует, что данные, считанные в рамках одной транзакции, не изменятся до её завершения (не допускаются неповторяемые чтения). Однако, могут возникать фантомные чтения.

🔹 SERIALIZABLE

Все транзакции выполняются последовательно, как если бы они были выполнены по очереди.

Реализуется через блокировки (Lock-based): БД ставит range locks — блокирует не только существующие строки, но и диапазоны, куда могут вставиться новые. Это устраняет все виды аномалий, но может значительно снизить производительность.

🐸 Библиотека собеса по Java

#concurrency

❓ В чём разница между ExecutorService.submit() и execute()?

execute() принимает Runnable, ничего не возвращает, асинхронно выполняет задачу.

submit() принимает Runnable или Callable, возвращает Future для отслеживания результата или статуса. Также позволяет отменить задачу через future.cancel() и обрабатывать исключения.

🐸 Библиотека собеса по Java

#concurrency

❓ Для чего нужен volatile?

volatile — это модификатор переменной, который гарантирует:

▪️ Видимость изменений между потоками
▪️ Запрет кэширования в регистре потока

Использовать стоит, когда:

▪️ Есть несколько потоков, которые читают/пишут одну переменную.
▪️ Нет сложных операций над этой переменной (например, инкрементов, которые требуют атомарности).

volatile не обеспечивает атомарности, поэтому для операций «чтение-модификация-запись» нужны синхронизация или атомарные типы (AtomicInteger, AtomicReference и т.п.).

🐸 Библиотека собеса по Java

#concurrency

❓ Какие существуют проблемы в многопоточной среде?

Основные проблемы многопоточности:

1️⃣ Race Condition — когда результат работы зависит от порядка выполнения потоков. Например, два потока одновременно изменяют одну переменную без синхронизации.

2️⃣ Deadlock — взаимная блокировка, когда потоки ждут друг друга. Классика: поток А держит ресурс 1 и ждёт ресурс 2, а поток Б держит ресурс 2 и ждёт ресурс 1.

2️⃣ Livelock — потоки активны, но не могут продолжить работу, постоянно реагируя на действия друг друга. Например, как два человека в коридоре, которые одновременно пытаются уступить дорогу.

4️⃣ Starvation — поток никогда не получает доступ к ресурсу из-за того, что другие потоки постоянно его перехватывают.

5️⃣ Memory Visibility — изменения, сделанные одним потоком, могут быть не видны другим из-за кэширования в CPU.

🐸 Библиотека собеса по Java

#concurrency

❓ Что такое false sharing в многопоточности и как его избежать?

False sharing возникает, когда разные потоки обновляют разные переменные, находящиеся в одной кэш-линии CPU.
Несмотря на отсутствие логической связи, процессор вынужден постоянно инвалидировать кэш, создавая задержки.

Последствия: высокая латентность, падение пропускной способности, резкое ухудшение производительности в hot-paths.

Как избежать:

• Разнести горячие поля по разным кэш-линиям → использовать @Contended (JDK 8+, требует -XX:-RestrictContended).
• Заполнять структуру “паддингом” вручную.
• Перепроектировать алгоритм, чтобы снизить частоту записи.

🐸 Библиотека собеса по Java

#concurrency