Пакет 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 включают конкретный класс 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 позволяет двум потокам обмениваться объектами в точке встречи и полезен в нескольких конструкциях конвейеров.

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

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

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

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

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

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

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

• Каждое действие в потоке предшествует каждому действию в этом потоке, которое следует за ним в порядке программы.
• Разблокировка (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 в других потоках.