🗊Презентация Java.SE.07 Multithreading

multithreading

Содержание Понятие многопоточности Работа с потоками Синхронизация Concurrent

Понятие многопоточности

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

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

Понятие многопоточности Многопоточность дает возможность писать очень эффективные программы, которые максимально используют CPU, потому что время его простоя можно свести к минимуму. Это особенно важно для интерактивной сетевой среды, в которой работает Java, потому что время простоя является общим. Скорость передачи данных по сети намного меньше, чем скорость, с которой компьютер может их обрабатывать. В традиционной однопоточной среде ваша программа должна ждать окончания каждой своей задачи, прежде чем она сможет перейти к следующей (даже при том, что большую часть времени CPU простаивает). Многопоточность позволяет получить доступ к этому времени простоя и лучше его использовать.

Понятие многопоточности Исполнительная система Java во многом зависит от потоков, и все библиотеки классов разработаны с учетом многопоточности. Java использует потоки для обеспечения асинхронности во всей среде. Ценность многопоточной среды лучше понимается по контрасту с ее аналогом. Однопоточные системы используют подход, называемый циклом событий с опросом (event loop with polling). В этой модели, единственный поток управления выполняется в бесконечном цикле, опрашивая единственную очередь событий, чтобы решить, что делать дальше. Как только этот механизм опроса возвращает сигнал готовности сетевого файла готов для чтения, цикл событий передает управление соответствующему обработчику событий. До возврата из этого обработчика в системе ничего больше случиться не может.

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

Понятие многопоточности Потоки существуют в нескольких состояниях. Поток может быть в состоянии выполнения. Может находиться в состоянии готовности к выполнению, как только он получит время CPU. Выполняющийся поток может быть приостановлен, что временно притормаживает его действие. Затем приостановленный поток может быть продолжен (возобновлен) с того места, где он был остановлен. Поток может быть блокирован в ожидании ресурса. В любой момент выполнение потока может быть завершено, что немедленно останавливает его выполнение.

Понятие многопоточности

Работа с потоками

Работа с потоками Многопоточная система Java построена на классе Thread, его методах и связанном с ним интерфейсе Runnable. Thread инкапсулирует поток выполнения. Так как вы не можете непосредственно обращаться к внутреннему состоянию потока выполнения, то будете иметь с ним дело через его полномочного представителя — экземпляр (объект) класса Thread, который его породил. Чтобы создать новый поток, ваша программа должна будет или расширять класс Thread или реализовывать интерфейс Runnable.

Работа с потоками. Example 01

Работа с потоками. Example 01

Работа с потоками. Example 01

Работа с потоками. Example 01 Результат:

Работа с потоками Некоторые методы класса Thread

Работа с потоками Когда Java-программа запускается, один поток начинает выполняться немедленно. Он обычно называется главным потоком. Главный поток важен по двум причинам: Это поток, из которого будут порождены все другие "дочерние" потоки. Это должен быть последний поток, в котором заканчивается выполнение. Когда главный поток останавливается, программа завершается.

Работа с потоками Хотя главный поток создается автоматически после запуска программы, он может управляться через Thread-объект. Для организации управления нужно получить ссылку на него, вызывая метод Currentrhread (), который является public static членом класса Thread. static Thread currentThread() Этот метод возвращает ссылку на поток, в котором он вызывается. Как только вы получаете ссылку на главный поток, то можете управлять им точно так же, как любым другим потоком.

Работа с потоками. Example 02

Работа с потоками. Example 02 Результат:

Работа с потоками Существуют два способа определения, закончился ли поток. Один из них позволяет вызывать метод isAlive() на потоке. Этот метод определен в Thread и его общая форма выглядит так: final boolean isAlive() Метод isAlive() возвращает true, если поток, на котором он вызывается — все еще выполняется. В противном случае возвращается false.

Работа с потоками В то время как isAlive() полезен только иногда, чаще для ожидания завершения потока вызывается метод join() следующего формата: final void join() throws InterruptedException Этот метод ждет завершения потока, на котором он вызван. Его имя происходит из концепции перевода потока в состояние ожидания, пока указанный поток не присоединит его. Дополнительные формы join() позволяют определять максимальное время ожидания завершения указанного потока.

Работа с потоками Состояние потока возвращается методами int getState() и boolean isAlive() класса Thread

Работа с потоками. Example 03

Работа с потоками. Example 03

Работа с потоками. Example 03 Результат:

Работа с потоками. Example 04

Работа с потоками. Example 04 Результат:

Работа с потоками Вызов метода yield() для исполняемого потока должен приводить к приостановке потока на некоторый квант времени, для того чтобы другие потоки могли выполнять свои действия. Однако если требуется надежная остановка потока, то следует использовать его крайне осторожно или вообще применить другой способ.

Работа с потоками Приоритеты потоков Планировщик потоков использует их приоритеты для принятия решений о том, когда нужно разрешать выполнение тому или иному потоку. Теоретически высокоприоритетные потоки получают больше времени CPU, чем низкоприоритетные. На практике, однако, количество времени CPU, которое поток получает, часто зависит от нескольких факторов помимо его приоритета. (Например, относительная доступность времени CPU может зависеть от того, как операционная система реализует многозадачный режим.)

Работа с потоками Высокоприоритетный поток может также упреждать низкоприоритетный (т. е. перехватывать у него управление процессором). Скажем, когда низкоприоритетный поток выполняется, а высокоприоритетный поток возобновляется (от ожидания на вводе/выводе, к примеру), высокоприоритетный поток будет упреждать низкоприоритетный. Теоретически, потоки равного приоритета должны получить равный доступ к CPU.

Работа с потоками Для безопасности потоки, которые совместно используют один и тот же приоритет, должны время от времени уступать друг другу управление. Это гарантирует, что все потоки имеют шанс выполниться под неприоритетной операционной системой. Практически, даже в неприоритетных средах, большинство потоков все еще получают шанс выполняться, потому что большинство из них неизбежно сталкивается с некоторыми блокирующими ситуациями, типа ожидания ввода/вывода. Когда это случается, блокированный поток приостанавливается, а другие могут продолжаться.

Работа с потоками Для установки приоритета потока используйте метод setPriority(), который является членом класса Thread. Вот его общая форма: final void setPriority(int level) где level определяет новую установку приоритета для вызывающего потока. Значение параметра level должно быть в пределах диапазона min_priority и max_priority. В настоящее время эти значения равны 1 и 10, соответственно. Чтобы вернуть потоку приоритет, заданный по умолчанию, определите norm_priority, который в настоящее время равен 5. Эти приоритеты определены в Thread как final-переменные.

Работа с потоками Вы можете получить текущую установку приоритета, вызывая метод getPriority() класса Thread, чей формат имеет следующий вид: final int getPriority() Реализации Java могут иметь радикально различное поведение, когда они переходят к планированию.

Работа с потоками. Example 05

Работа с потоками. Example 05

Работа с потоками. Example 05 Результат:

Работа с потоками Группы потоков Для того, чтобы отдельный поток не мог начать останавливать и прерывать все потоки подряд, введено понятие группы. Поток может оказывать влияние только на потоки, которые находятся в одной с ним группе. Группу потоков представляет класс ThreadGroup. Такая организация позволяет защитить потоки от нежелательного внешнего воздействия.

Работа с потоками Группа потоков может содержать другие группы, что позволяет организовать все потоки и группы в иерархическое дерево, в котором каждый объект ThreadGroup, за исключением корневого, имеет родителя. Класс ThreadGroup обладает методами для изменения свойств всех входящих в него потоков, таких, как приоритет, daemon и т.д. Метод list() позволяет получить список потоков.

Работа с потоками Все потоки, объединенные группой, имеют одинаковый приоритет. Чтобы определить, к какой группе относится поток, следует вызвать метод getThreadGroup(). Если поток до включения в группу имел приоритет выше приоритета группы потоков, то после включения значение его приритета станет равным приоритету группы. Поток же со значением приоритета более низким, чем приоритет группы после включения в оную, значения своего приоритета не изменит.

Работа с потоками. Example 06

Работа с потоками. Example 06

Работа с потоками. Example 06

Работа с потоками. Example 06

Работа с потоками. Example 06 Результат:

Работа с потоками Потоки-демоны Потоки-демоны работают в фоновом режиме вместе с программой, но не являются неотъемлемой частью программы. Если какой-либо процесс может выполняться на фоне работы основных потоков выполнения и его деятельность заключается в обслуживании основных потоков приложения, то такой процесс может быть запущен как поток-демон. С помощью метода setDaemon(boolean value), вызванного вновь созданным потоком до его запуска, можно определить поток-демон. Метод boolean isDaemon() позволяет определить, является ли указанный поток демоном или нет.

Работа с потоками. Example 07

Работа с потоками. Example 07

Работа с потоками. Example 07 Результат:

синхронизация

Синхронизация Правила, которые определяют, когда переключение контекста имеет место. Поток может добровольно отказаться от управления. Это делается явно, переходом в режим ожидания или блокированием на ожидающем вводе/выводе. В этом сценарии просматриваются все потоки, и CPU передается самому высокоприоритетному потоку, который готов к выполнению. Поток может быть приостановлен более приоритетным потоком. В этом случае занимающий процессор низкоприоритетный поток временно останавливается (независимо от того, что он делает) потоком с более высоким приоритетом. Данный механизм называется упреждающей многозадачностью (preemptive multitasking).

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

Синхронизация Для этой цели Java эксплуатирует модель синхронизации процессов — монитор. Монитор — это механизм управления связью между процессами. Вы можете представлять монитор, как очень маленький блок, который содержит только один поток. Как только поток входит в монитор, все другие потоки должны ждать, пока данный не выйдет из монитора. Таким образом, монитор можно использовать для защиты совместно используемого (разделяемого) ресурса от управления несколькими потоками одновременно.

Синхронизация Большинство многопоточных систем создает мониторы как объекты, которые ваша программа должна явно получить и использовать. В Java-системе нет класса с именем Monitor. Вместо этого, каждый объект имеет свой собственный неявный монитор, который вводится автоматически при вызове одного из методов объекта. Как только поток оказывается внутри синхронизированного метода, никакой другой поток не может вызывать иной синхронизированный метод того же объекта.

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

Синхронизация Когда несколько потоков нуждаются в доступе к разделяемому ресурсу, им необходим некоторый способ гарантии того, что ресурс будет использоваться одновременно только одним потоком. Процесс, с помощью которого это достигается, называется синхронизацией. Ключом к синхронизации является концепция монитора (также называемая семафором). Монитор — это объект, который используется для взаимоисключающей блокировки (mutually exclusive lock), или mutex.

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

Синхронизация Синхронизация в Java проста потому, что каждый объект имеет свой собственный неявный связанный с ним монитор. Чтобы ввести монитор объекта, просто вызывают метод, который был модифицирован ключевым словом synchronized. Пока поток находится внутри синхронизированного метода, все другие потоки, пытающиеся вызвать его (или любой другой синхронизированный метод) на том же самом экземпляре, должны ждать. Чтобы выйти из монитора и оставить управление объектом следующему ожидающему потоку, владелец монитора просто возвращается из синхронизированного метода.

Синхронизация. Example 08

Синхронизация. Example 08

Синхронизация. Example 08 Результат:

Синхронизация Хотя определения синхронизированных методов внутри классов — это простые и эффективные средства достижения синхронизации, они не будут работать во всех случаях. Например, вы хотите синхронизировать доступ к объектам класса, который не был разработан для многопоточного доступа. То есть класс не использует синхронизированные методы. Кроме того, этот класс был создан не вами, а третьим лицом, и вы не имеете доступа к исходному коду. Таким образом, вы не можете добавлять спецификатор synchronized к соответствующим методам в классе. Решение данной проблемы весьма просто. Нужно поместить вызовы методов, определенных этим классом внутрь синхронизированного блока.

Синхронизация Вот общая форма оператора synchronized: synchronized(object) { // операторы для синхронизации } где object — ссылка на объект, который нужно синхронизировать. Если нужно синхронизировать одиночный оператор, то фигурные скобки можно опустить. Блок гарантирует, что вызов метода, который является членом объекта object, происходит только после того, как текущий поток успешно ввел монитор объекта.

Синхронизация. Example 09

Синхронизация. Example 09

Синхронизация. Example 09 Результат:

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

Синхронизация Например, рассмотрим классическую проблему организации очереди, где один поток производит некоторые данные, а другой — их потребляет. Предположим, что, прежде чем генерировать большее количество данных, производитель должен ждать, пока потребитель не закончит свою работу. В системе же опроса, потребитель тратил бы впустую много циклов CPU на ожидание конца работы производителя. Как только производитель закончил свою работу, он вынужден начать опрос, затрачивая много циклов CPU на ожидание конца работы потребителя. Ясно, что такая ситуация нежелательна. Чтобы устранить опросы, Java содержит изящный механизм межпроцессовой связи через методы wait(), notify() и notifyAll(). Они реализованы как final-методы в классе object, поэтому доступны всем классам

Синхронизация wait () сообщает вызывающему потоку, что нужно уступить монитор и переходить в режим ожидания ("спячки"), пока некоторый другой поток не введет тот же монитор и не вызовет notify (); notify () "пробуждает" первый поток (который вызвал wait ()) на том же самом объекте; notifyAll() пробуждает все потоки, которые вызывали wait () на том же самом объекте. Первым будет выполняться самый высокоприоритетный поток. Эти методы объявляются в классе Object в следующей форме: final void wait() throws InterruptedException final void notify() final void notifyAll()

Синхронизация. Example 10

Синхронизация. Example 10

Синхронизация. Example 10 Результат:

Синхронизация Специальный тип ошибки, которую вам нужно избегать и которая специально относится к многозадачности, это — (взаимная) блокировка. Она происходит, когда два потока имеют циклическую зависимость от пары синхронизированных объектов. Например, предположим, что один поток вводит монитор в объект х, а другой поток вводит монитор в объект у. Если поток в х пробует вызвать любой синхронизированный метод объекта у, это приведет к блокировке, как и ожидается. Однако если поток в у, в свою очередь, пробует вызвать любой синхронизированный метод объекта х, то он будет всегда ждать, т. к. для получения доступа к х, он был бы должен снять свою собственную блокировку с у, чтобы первый поток мог завершиться.

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

Синхронизация Приостановка выполнения потока иногда полезна. Например, отдельные потоки могут использоваться, чтобы отображать время дня. Если пользователь не хочет видеть отображения часов, то их поток может быть приостановлен. В любом случае приостановка потока — простое дело. После приостановки перезапуск потока также не сложен. Механизмы приостановки, остановки и возобновления потоков различны для Java 2 и более ранних версий Java.

Синхронизация До Java 2 для приостановки и перезапуска выполнения потока программа использовала методы suspend () и resume (), которые определены в классе Thread. Они имеют такую форму: final void suspend() final void resume() Класс Thread также определяет метод с именем stop(), который останавливает поток. Его сигнатура имеет следующий вид: void stop() Если поток был остановлен, то его нельзя перезапускать с помощью метода resume().

Синхронизация В Java 2 запрещено использовать методы suspend(), resume() или stop() для управления потоком. Поток должен быть спроектирован так, чтобы метод run() периодически проверял, должен ли этот поток приостанавливать, возобновлять или останавливать свое собственное выполнение. Это, как правило, выполняется применением флажковой переменной, которая указывает состояние выполнения потока. Пока флажок установлен на "выполнение", метод run() должен продолжать позволять потоку выполняться. Если эта переменная установлена на "приостановить", поток должен сделать паузу. Если она установлена на "стоп", поток должен завершиться.

concurrent

Сoncurrent В Java версии 1.5 был добавлен новый пакет, содержащий много полезных возможностей, касающихся синхронизации и параллелизма: java.util.concurrent. В версии 1.5 языка добавлены пакеты классов java.util.concurrent.locks, java.util.concurrent.atomic, java.util.concurrent, возможности которых обеспечивают более высокую производительность, масштабируемость, построение потокобезопасных блоков параллельных (concurrent) классов, вызов утилит синхронизации, использование семафоров, ключей и atomic-переменных.

Сoncurrent Ограниченно потокобезопасные (thread safe) коллекции и вспомогательные классы управления потоками сосредоточены в пакете java.util.concurrent. Среди них можно отметить: параллельные классы очередей ArrayBlockingQueue (FIFO очередь с фиксированой длиной), PriorityBlockingQueue (очередь с приоритетом) и ConcurrentLinkedQueue (FIFO очередь с нефиксированой длиной);

Сoncurrent параллельные аналоги существующих синхронизированых классов-коллекций ConcurrentHashMap (аналог Hashtable) и CopyOnWriteArrayList (реализация List, оптимизированная для случая, когда количество итераций во много раз превосходит количество вставок и удалений); механизм управления заданиями, основанный на возможностях класса Executor, включающий пул потоков и службу их планирования;

Сoncurrent высокопроизводительный класс Lock, поддерживающий ограниченные ожидания снятия блокировки, прерываемые попытки блокировки, очереди блокировки и установку ожидания снятия нескольких блокиро­вок посредством класса Condition; классы синхронизации общего назначения, такие как Semaphore, CountDownLatch (позволяет потоку ожидать завершения нескольких операций в других потоках), CyclicBarrier (позволяет нескольким потокам ожидать момента, когда они все достигнут какой-либо точки) и Exchanger (позволяет потокам синхронизироваться и обмениваться информацией);

Сoncurrent классы атомарных переменных (AtomicInteger, AtomicLong, AtomicReference), а также их высокопроизводительные аналоги SyncronizedInt и др.; обработка неотловленных прерываний: класс Thread теперь поддерживает установку обработчика на неотловленные прерывания (подобное ранее было доступно только в ThreadGroup).

Сoncurrent Executors Пакет java.util.concurrent содержит три Executor-интерфейса: Executor ExecutorService ScheduledExecutorService Также библиотека java.util.concurrent содержит специальный класс, который называют Executors. Объекты данного класса помогаю работать с потока не на прямую, а использовать исполнители. Данное решение бывает очень полезно когда вам необходимо запустить множество потоков, выполняющих одинаковые задачи.

Сoncurrent. Example 11

Сoncurrent Сначала создается объект класса ExecutorService. После чего вызывается метод execute, которому в качестве параметра необходимо передать объект, созданного нами класса, который мы хотим передать исполнителю. После передачи потока, исполнитель автоматически запускает его. Исполнитель позволяет нам экономить время на создание отдельных потоков и на их запуск. Результат:

Сoncurrent В примере объекту «ex» присваивается специальная реализация Executors.newCachedThreadPool(). Данная реализация применяется в тех случаях, когда вы заранее неизвестно, какое количество потоков будет передаваться исполнителю. Если же количество потоков заранее известно необходимо использовать реализацию newFixedThreadPool(int) в качестве параметра ей нужно передать число потоков, которое мы будем использовать, в нашем случае 2. Это дает большой выигрыш в быстродействии, так как все потоки создаются сразу. Если же необходимо передавать исполнителю только один объект класса, то для таких целей можно использовать реализацию newSingleThreadExecutor(). Если при использовании данной реализации исполнителю передается несколько потоков, то они попадут в очередь, и каждый из них будет запускаться только после завершения работы предыдущего.

Сoncurrent ExecutorService Данный интерфейс является расширением интерфейса Executor и добавляет следующие полезные возможности: Возможность остановить выполняемый процесс Возможность выполнения не только Runnable объектов, но и java.util.concurrent.Callable. Основное их отличие от Runnable объектов – возможность возвращать значение потоку, из которого делался вызов. Возможность возвращать вызывавшему потоку объект java.util.concurrent.Future, который содержит среди прочего и возвращаемое значение.

Сoncurrent Возврат значений из задач. Интерфейс Callable Очень часто нам необходимо, чтобы поток после выполнения своей работы возвращал нам некоторое значение, в таких ситуациях нам необходимо использовать интерфейс Callable при создании класса. Он очень похож на Runnable, но имеет несколько отличий. В первую очередь после объявления данного интерфейса необходимо указать тип параметра, который должен вернуть поток. Вместо метода run() необходимо использовать метод call().

Сoncurrent. Example 12

Сoncurrent Теперь рассмотрим способ получения полученного значения, используя исполнители. Для передачи объекта, созданного нами класса исполнителя, используется метод «submit». При вызове данного метода создается объект типа «Future» параметризованный по типу результата возвращаемого Callable. В нашем случае «Future<Integer>». В свою очередь из этого объекта мы уже можем получить нужный нам результат, используя метод get(). Данный метод всегда необходимо оборачивать в блок try-catch , так как поток еще может не закончить свою работу, а метод get() уже будет вызван. Для проверки завершенности потока используется метод isDone(), он возвращает логическое значение.

Сoncurrent. Example 13 Результат:

Сoncurrent Управление потоками. Ожидание Существует несколько методов управления потоками. Давайте рассмотрим метод переводящий поток в состояние ожидания. Для этого у класса «TimeUnit» выберем метод отвечающий за размерность времени, например «TimeUnit.MICROSECONDS», у этого метода есть метод «sleep», которому в качестве параметра нужно передать число, отвечающее за величину второго параметра(время проведенное в ожидании). При реализации данного метода его необходимо поместить в блок try-catch.

Сoncurrent. Example 14

Сoncurrent Механизм управления мьютексами Lock Lock является явным механизмом управления мьютексами. Он находиться в библиотеке java.util.concurrent. Объект класса Lock можно явно создать в программе и установить или снять блокировку с помощью его методов. К плюсам данного объекта можно отнести возможность отлавливания исключений и другие. Рассмотрим реализацию Lock для класса MyTread.

Сoncurrent. Example 15

Сoncurrent Атомарные операции. Volatile Атомарные операции- это операции, которые не могут быть прерваны планировщиком потоков. Чтение и запись примитивных переменных кроме double и long являются атомарными. Даже если операция является атомарной, значение переменной может хранится в кэше ядра, и быть не видным другому потоку, поэтому для обеспечение видимости внутри приложения существует ключевое слово volatile. Но данное ключевое слово не обеспечивает атомарности операциям, не смотря на то что после записи, значение поле будет отображено сразу при всех операциях чтения. Так что приведенный код все еще содержит ошибку некорректного доступа.

Сoncurrent. Example 16 Атомарные классы Попробуем разрешить конфликт с помощью атомарных классов: AtomicInteger, Atomic Long ,AtomicReference и т.д. Данный класс гарантирует атомарное выполнение операций.

Сoncurrent. Example 17 Синхронизованные коллекции

Сoncurrent. Example 17

Сoncurrent. Example 17

Сoncurrent. Example 17

Сoncurrent. Example 17 Результат:

Сoncurrent. Example 17 А вот возможный результат использования в этом примере PriorityQueue

Ihar Blinou, PhD Java.SE.07 MultiThreading