Многопоточность Java Flashcards
Java multithreading definitions
Happens Before
Это отношение, определённое в модели памяти Java (Java Memory Model, JMM), которое задаёт порядок исполнения операций в многопоточной среде. Если операция A happens-before операции B, это гарантирует, что все изменения сделанные одним потоком до операции А будут видны другому потоку после операции B
Какие операции связаны отношением happens-before
- Освобождение монитора одним потоком happens-before захват монитора другим потоком (выход из блока synchronized happens-before вход другого потока в synchronized блок)
- Запись в volatile переменную happens-before последующего чтения этой же переменной другим потоком
- Вызов метода Thread.start() для потока happens-before началом выполнения кода в этом потоке
- Вызов Thread.join() для потока happens-before возвращением метода join() в вызывающем потоке
- Инициализация final переменной в конструкторе happens-before любым доступом к этой переменной из других потоков
- Транзитивность: Если A happens-before B, а B happens-before C, то A happens-before C
Монитор
Монитор в Java — это механизм синхронизации, встроенный в объект, который используется для координации доступа потоков к общим ресурсам. Он помогает предотвратить проблемы гонки данных (data race) и обеспечивает эксклюзивный доступ к критическим секциям кода.
Каждый объект в Java имеет встроенный монитор, который используется совместно с ключевым словом synchronized. Монитор работает как взаимное исключение (mutex), позволяя только одному потоку в момент времени входить в синхронизированный блок или метод, связанный с этим объектом.
Характеристики монитора
- Эксклюзивный доступ: Только один поток может захватить монитор объекта в определённый момент времени. Пока поток удерживает монитор, другие потоки не могут войти в синхронизированные методы или блоки того же объекта.
- Синхронизация на уровне объекта: Монитор привязан к конкретному объекту. Если несколько потоков работают с разными экземплярами объекта, их выполнение не блокируется.
- Автоматическое освобождение: Монитор автоматически освобождается, когда поток покидает синхронизированный блок/метод или вызывает исключение.
Как работают методы wait() и notify()/notifyAll()?
Эти методы определены у класса Object и предназначены для взаимодействия потоков между собой при межпоточной синхронизации.
wait(): освобождает монитор и переводит вызывающий поток в состояние ожидания до тех пор, пока другой поток не вызовет метод notify()/notifyAll();
notify(): продолжает работу потока, у которого ранее был вызван метод wait();
notifyAll(): возобновляет работу всех потоков, у которых ранее был вызван метод wait().
Когда вызван метод wait(), поток освобождает блокировку на объекте и переходит из состояния Работающий (Running) в состояние Ожидания (Waiting). Метод notify() подаёт сигнал одному из потоков, ожидающих на объекте, чтобы перейти в состояние Работоспособный (Runnable). При этом невозможно определить, какой из ожидающих потоков должен стать работоспособным. Метод notifyAll() заставляет все ожидающие потоки для объекта вернуться в состояние Работоспособный (Runnable). Если ни один поток не находится в ожидании на методе wait(), то при вызове notify() или notifyAll() ничего не происходит.
Поток может вызвать методы wait() или notify() для определённого объекта, только если он в данный момент имеет блокировку на этот объект. wait(), notify() и notifyAll() должны вызываться только из синхронизированного кода.
Race Condition vs Data Race
Race condition (состояние гонки) - возникает, когда правильность работы программы зависит от порядка или времени выполнения потоков.
Если два или более потока обращаются к общим данным и результат программы меняется в зависимости от того, какой поток первым завершает операцию, это race condition.
Ключевые черты:
Может происходить даже в случае синхронизированного доступа к данным, если логика программы не учитывает возможные сценарии выполнения потоков.
Примером race condition может быть проблема “потерянного уведомления” при некорректном использовании wait() и notify().
Data race (гонка данных) - происходит, когда два потока одновременно выполняют доступ к одной и той же переменной без должной синхронизации и хотя бы один из потоков записывает данные.
Dead Lock vs Live Lock vs Starvation
Dead lock - ситуация в многопоточной среде, при которой несколько потоков находятся в состоянии ожидания ресурсов, занятых друг другом, и ни один из них не может продолжать свое выполнение.
Live lock - похож на dead lock за исключением того, что они находятся не в ожидании, а выполняют бесполезную работу нагружая ресурсы процессора.
Starvation или голодание - состояние, при котором ресурсов не хватает на все потоки. Пока одни потоки берут на себя все время выполнения, другие не могут выполнитсья.
(разобрать примеры и реализовать)
Состояния потока
New
Waiting/Blocked
Runnable
Running
Dead
Park (поток пытается захватить лок)
Новый (New). После создания экземпляра потока, он находится в состоянии Новый до тех пор, пока не вызван метод start(). В этом состоянии поток не считается живым.
Работоспособный (Runnable). Поток переходит в состояние Работоспособный, когда вызывается метод start(). Поток может перейти в это состояние также из состояния Работающий или из состояния Блокирован. Когда поток находится в этом состоянии, он считается живым.
Работающий (Running). Поток переходит из состояния Работоспособный в состояние Работающий, когда Планировщик потоков выбирает его как работающий в данный момент.
Живой, но не работоспособный (Alive, but not runnable). Поток может быть живым, но не работоспособным по нескольким причинам:
Ожидание (Waiting). Поток переходит в состояние Ожидания, вызывая метод wait(). Вызов notify() или notifyAll() может перевести поток из состояния Ожидания в состояние Работоспособный.
Сон (Sleeping). Метод sleep() переводит поток в состояние Сна на заданный промежуток времени в миллисекундах.
Блокировка (Blocked). Поток может перейти в это состояние, в ожидании ресурса, такого как ввод/вывод или из-за блокировки другого объекта. В этом случае поток переходит в состояние Работоспособный, когда ресурс становится доступен.
Мёртвый (Dead). Поток считается мёртвым, когда его метод run() полностью выполнен. Мёртвый поток не может перейти ни в какое другое состояние, даже если для него вызван метод start().
Существуют перечисление Thread.State, содержащее значения возможных состояний потока: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED.
Что такое «зелёные потоки» и есть ли они в Java?
Зелёные (легковесные) потоки(green threads) - потоки эмулируемые виртуальной машиной или средой исполнения. Создание зелёного потока не подразумевает под собой создание реального потока ОС.
Виртуальная машина Java берёт на себя заботу о переключении между разными green threads, а сама машина работает как один поток ОС. Это даёт несколько преимуществ. Потоки ОС относительно дороги в большинстве POSIX-систем. Кроме того, переключение между native threads гораздо медленнее, чем между green threads.
Это всё означает, что в некоторых ситуациях green threads гораздо выгоднее, чем native threads. Система может поддерживать гораздо большее количество green threads, чем потоков OС. Например, гораздо практичнее запускать новый green thread для нового HTTP-соединения к веб-серверу, вместо создания нового native thread.
Когда может возникнуть состояние гонки даже если метод синхронизирован?
Синхронизация внутри метода гарантирует корректность выполнения только в рамках самого метода. Если же логика разрывается на несколько методов (например, проверка и действие), синхронизация на уровне метода уже может быть недостаточной.
Что такое демон-поток
Потоки-демоны (daemon threads) в Java — это специальные фоновые потоки, предназначенные для выполнения вспомогательных задач в процессе работы приложения. Они работают в фоновом режиме и автоматически завершаются, когда все обычные пользовательские потоки приложения завершены. Основная цель потоков-демонов — обслуживать главные рабочие потоки.
