Многопоточность

Состояние гонки — это когда корректность программы зависит от непредсказуемого порядка обращения двух или более потоков к разделяемому изменяемому состоянию одновременно. Классический случай: два потока читают, увеличивают и записывают один счётчик, и чередующиеся шаги теряют обновление. Лечат сериализацией доступа через synchronized, блокировку или атомарные операции.

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

Взаимоблокировка — это когда два или более потока удерживают каждый блокировку, нужную другому, и ждут вечно, так что никто не может продолжить. Классический случай: поток A держит блокировку 1 и хочет блокировку 2, а поток B держит блокировку 2 и хочет блокировку 1. Предотвращают её единым глобальным порядком захвата, чтобы все потоки брали блокировки в одной последовательности, через tryLock с таймаутом для отступа или удержанием меньшего числа блокировок.

Два базовых способа: наследовать Thread и переопределить run(), либо реализовать Runnable и передать его в Thread. Реализация Runnable предпочтительнее, так как оставляет свободным единственный слот наследования класса и отделяет задачу от исполнителя. Для задач, возвращающих результат или бросающих проверяемое исключение, реализуют Callable и отправляют его в ExecutorService, который возвращает Future.

Две ошибки. Первая: лямбда захватывает i, но переменная цикла не является effectively final, поэтому код не компилируется — скопируйте её в финальную локальную (final int n = i;) и печатайте n. Вторая: System.exit(0) немедленно завершает JVM, убивая спящие потоки до печати — уберите его (или сначала join каждый поток), чтобы программа дождалась их вывода.

volatile гарантирует видимость: каждое чтение и запись поля идут прямо в главную память, а не в локальный кеш потока, поэтому другие потоки всегда видят последнее записанное значение, а компилятор не переупорядочивает обращения вокруг него. Оно НЕ обеспечивает атомарность составных операций вроде i++, которая является read-modify-write и которую два потока всё ещё могут чередовать, теряя обновления.

wait() — это метод Object, который ОСВОБОЖДАЕТ монитор и паркует поток, пока другой поток не вызовет notify()/notifyAll() на том же объекте; его нужно вызывать, уже удерживая этот монитор, обычно внутри synchronized-блока. sleep() — это статический метод Thread, который просто приостанавливает текущий поток на заданное время и УДЕРЖИВАЕТ все блокировки, которыми он владеет.

Состояние гонки — это ошибка времени, когда потоки чередуют доступ к разделяемому состоянию и портят его; лечат сериализацией доступа блокировками или атомарными операциями. Взаимоблокировка — это потоки, удерживающие каждый нужную другому блокировку и ждущие вечно; предотвращают единым порядком захвата или таймаутами tryLock. Живая блокировка — это потоки, постоянно реагирующие друг на друга и меняющие состояние, но не продвигающиеся; помогает случайная задержка.

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

Модель памяти определяет отношение happens-before: если действие A happens-before B, всё записанное в A видно в B и не может быть переупорядочено за него. Освобождение монитора, запись volatile-поля и старт потока создают такое ребро. Без него чтения переупорядочиваются, и поток может бесконечно видеть устаревшее значение.

ThreadLocal даёт каждому потоку собственную независимую копию значения, которая лежит в карте, привязанной к объекту Thread, поэтому синхронизация для чтения и записи не нужна. InheritableThreadLocal вдобавок копирует значение родителя в дочерний поток в момент его создания. Значения нужно удалять явно: поток из пула переживает задачу и держит запись живой.

notify() будит один произвольный поток, ожидающий на мониторе объекта; выбрать какой именно нельзя. notifyAll() будит все ожидающие потоки, и они затем заново соперничают за блокировку, каждый перепроверяя своё условие перед продолжением. Предпочитайте notifyAll(), когда потоки ждут разных условий, ведь notify() может разбудить не тот поток и оставить готовый к работе поток ждать навсегда.

Оба потока BLOCKED на мониторе, и адреса мониторов перекрещены: worker-1 держит 0x…41180 и ждёт 0x…3f2c8, а worker-2 держит 0x…3f2c8 и ждёт 0x…41180. Это циклическое ожидание на двух мониторах Account — deadlock: transfer захватывает счета в порядке аргументов вызывающего, поэтому два встречных перевода берут их в противоположном порядке. Лечится единым глобальным порядком захвата (например, по id счёта) или tryLock с таймаутом и отступом.