Пакет java.util.concurrent

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

Исполнители

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

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

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

Очереди

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

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

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

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

Временные интервалы

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

Синхронизаторы

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

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

Конкурентные коллекции

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

Префикс «Конкурентный», используемый с некоторыми классами в этом пакете, — это сокращение, указывающее на несколько различий с аналогичными классами «синхронизированными». Например 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. В частности:

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

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