Пакет java.util.concurrent

Утилитарные классы, обычно полезные в многопоточной программировании. Этот пакет включает несколько небольших стандартизированных расширяемых фреймворков, а также некоторые классы, которые предоставляют полезную функциональность и в противном случае являются трудоёмкими или сложными для реализации. Вот краткие описания основных компонентов. См. также пакеты java.util.concurrent.locks и java.util.concurrent.atomic.

Исполнители (Executors)

Интерфейсы. Executor — это простой стандартизированный интерфейс для определения пользовательских многопоточных подсистем, включая пулы потоков, асинхронное ввод-вывод и лёгкие фреймворки задач. В зависимости от конкретного класса Executor, задачи могут выполняться в новом созданном потоке, в существующем потоке выполнения задач или в потоке, вызывающем execute, и могут выполняться последовательно или параллельно. ExecutorService предоставляет более полный фреймворк асинхронного выполнения задач. ExecutorService управляет очередью и планированием задач и позволяет контролировать завершение. Подинтерфейс ScheduledExecutorService и связанные интерфейсы добавляют поддержку выполнения задач с задержкой и периодически. ExecutorServices предоставляют методы для организации асинхронного выполнения любой функции, выраженной как Callable, аналог Runnable с возвращаемым результатом. Future возвращает результаты функции, позволяет определить, завершено ли выполнение, и предоставляет способ отмены выполнения. RunnableFuture является Future, который обладает методом run, который при выполнении устанавливает свои результаты.

Реализации. Классы ThreadPoolExecutor и ScheduledThreadPoolExecutor предоставляют настраиваемые, гибкие пулы потоков. Класс Executors предоставляет фабричные методы для наиболее распространённых типов и конфигураций Executors, а также несколько утилитарных методов для их использования. Другие утилиты, основанные на Executors, включают конкретный класс FutureTask, предоставляющий общую расширяемую реализацию Futures, и ExecutorCompletionService, который помогает в координации обработки групп асинхронных задач.

Класс ForkJoinPool предоставляет Executor, в первую очередь предназначенный для обработки экземпляров ForkJoinTask и его подклассов. Эти классы используют планировщик с кражей работы, который достигает высокой производительности для задач, соответствующих ограничениям, которые часто имеют место при вычислениях с интенсивной параллельной обработкой.

Очереди (Queues)

Класс ConcurrentLinkedQueue предоставляет эффективную масштабируемую потокобезопасную, неблокирующую очередь FIFO. Класс ConcurrentLinkedDeque аналогичен, но дополнительно поддерживает интерфейс Deque.

Пять реализаций в java.util.concurrent поддерживают расширенный интерфейс BlockingQueue, который определяет блокирующие версии put и take: LinkedBlockingQueue, ArrayBlockingQueue, SynchronousQueue, PriorityBlockingQueue и DelayQueue. Различные классы охватывают наиболее распространённые контексты использования для задач производителя-потребителя, обмена сообщениями, параллельного выполнения задач и связанных с ними многопоточных конструкций.

Расширенный интерфейс TransferQueue и реализация LinkedTransferQueue вводят синхронный transfer метод (наряду со связанными функциями), в котором производитель может выборочно заблокироваться, ожидая своего потребителя.

Интерфейс BlockingDeque расширяет BlockingQueue для поддержки операций FIFO и LIFO (стековой). Класс LinkedBlockingDeque предоставляет реализацию.

Временные интервалы (Timing)

Класс TimeUnit предоставляет несколько гранул (включая наносекунды) для указания и управления операциями с тайм-аутом. Большинство классов в пакете содержат операции на основе тайм-аутов в дополнение к неопределённым ожиданиям. Во всех случаях, когда используются тайм-ауты, тайм-аут указывает минимальное время ожидания метода перед указанием о том, что он истек. Реализации прилагают «максимальные усилия» для обнаружения тайм-аутов как можно скорее после их возникновения. Однако может пройти неопределённое время между обнаружением тайм-аута и фактическим повторным выполнением потока после этого тайм-аута. Все методы, принимающие параметры тайм-аута, рассматривают значения, меньшие или равные нулю, как означающие, что не нужно ждать вообще. Чтобы ждать «бесконечно», можно использовать значение Long.MAX_VALUE.

Синхронизаторы (Synchronizers)

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

• Semaphore — классический инструмент параллельности.
• CountDownLatch — очень простая, но очень распространённая утилита для блокировки до тех пор, пока определённое количество сигналов, событий или условий не будут выполнены.
• CyclicBarrier — это перезапускаемая многосторонняя точка синхронизации, полезная в некоторых стилях параллельного программирования.
• Phaser предоставляет более гибкую форму барьера, которая может использоваться для управления фазами вычислений среди нескольких потоков.
• Exchanger позволяет двум потокам обмениваться объектами в точке встречи и полезен в нескольких конструкциях конвейеров.

Конкурентные коллекции (Concurrent Collections)

Помимо очередей, этот пакет предоставляет реализации Collection, предназначенные для использования в многопоточных контекстах: ConcurrentHashMap, ConcurrentSkipListMap, ConcurrentSkipListSet, CopyOnWriteArrayList и CopyOnWriteArraySet. Когда ожидается, что несколько потоков будут обращаться к заданной коллекции, ConcurrentHashMap обычно предпочтительнее синхронизированной HashMap, а ConcurrentSkipListMap обычно предпочтительнее синхронизированной TreeMap. CopyOnWriteArrayList предпочтительнее синхронизированного ArrayList когда ожидаемое количество чтений и проходов значительно превышает количество обновлений списка.

Префикс «Concurrent», используемый с некоторыми классами в этом пакете, является сокращением, указывающим на несколько отличий от аналогичных «синхронизированных» классов. Например, java.util.Hashtable и Collections.synchronizedMap(new HashMap()) синхронизированы. Но ConcurrentHashMap «конкурентная». Конкурентная коллекция потокобезопасна, но не регулируется единственным блокирующим замком. В частности, в случае ConcurrentHashMap она безопасно допускает любое количество одновременных чтений и большое количество одновременных записей. Синхронизированные классы могут быть полезны, когда вам нужно предотвратить весь доступ к коллекции через один замок, за счёт худшей масштабируемости. В других случаях, когда ожидается, что несколько потоков будут обращаться к общей коллекции, «конкурентные» версии обычно предпочтительнее. А несинхронизированные коллекции предпочтительнее, когда либо коллекции не совместно используются, либо к ним можно получить доступ только при удержании других замков.

Большинство реализаций конкурентных коллекций (включая большинство очередей) также отличаются от обычных java.util соглашений тем, что их Итераторы и Разделители обеспечивают слабо согласованную, а не быструю проверку прохода:

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

Свойства согласованности памяти

Глава 17 спецификации языка Java определяет отношение happens-before для операций с памятью, таких как чтение и запись общих переменных. Результаты записи одним потоком гарантированы для видимости при чтении другим потоком только в том случае, если операция записи happens-before операции чтения. Конструкции synchronized и volatile, а также методы Thread.start() и Thread.join() могут образовывать отношения happens-before. В частности:

• Каждое действие в потоке предшествует каждому последующему действию в этом потоке в порядке программы.
• Разблокировка (synchronized блока или выхода из метода) монитора предшествует каждой последующей блокировке (synchronized блока или входа в метод) того же самого монитора. А поскольку отношение предшествует транзитивно, все действия потока до разблокировки предшествуют всем действиям после блокировки монитора этим потоком.
• Запись в volatile поле предшествует каждой последующей чтению того же самого поля. Записи и чтения volatile полей имеют аналогичные эффекты согласованности памяти, как вход и выход из мониторов, но не подразумевают взаимную блокировку.
• Вызов start потока предшествует любому действию в запущенном потоке.
• Все действия в потоке предшествуют любому другому потоку, успешно возвращающемуся из join в этом потоке.

Методы всех классов в java.util.concurrent и его подпакетах расширяют эти гарантии на синхронизацию более высокого уровня. В частности:

• Действия в потоке до размещения объекта в любой конкурентной коллекции предшествуют действиям, последующим за доступом или удалением этого элемента из коллекции в другом потоке.
• Действия в потоке до отправки Runnable в Executor предшествуют его началу выполнения. Аналогично для Callables, отправленной в ExecutorService.
• Действия, выполняемые асинхронным вычислением, представленным Future, предшествуют действиям, последующим за получением результата через Future.get() в другом потоке.
• Действия до «выпуска» методов синхронизатора, таких как Lock.unlock, Semaphore.release, и CountDownLatch.countDown предшествуют действиям, последующим за успешным «приобретением» методами, такими как Lock.lock, Semaphore.acquire, Condition.await, и CountDownLatch.await, на том же объекте синхронизатора в другом потоке.
• Для каждой пары потоков, которые успешно обмениваются объектами через Exchanger, действия до exchange() в каждом потоке предшествуют действиям, последующим за соответствующим exchange() в другом потоке.
• Действия до вызова CyclicBarrier.await и Phaser.awaitAdvance (а также его вариантов) предшествуют действиям, выполняемым действием барьера, и действия, выполняемые действием барьера, предшествуют действиям, последующим за успешным возвратом из соответствующего await в других потоках.