Пакет 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 — очень простая, но очень распространённая утилита для блокировки до тех пор, пока заданное количество сигналов, событий или условий не выполнится.
• A CyclicBarrier — это многосторонний контрольно-пропускной пункт, который можно перезапустить и который полезен в некоторых стилях параллельного программирования.
• A Phaser обеспечивает более гибкую форму барьера, которая может использоваться для управления поэтапными вычислениями среди нескольких потоков.
• A Exchanger позволяет двум потокам обмениваться объектами в точке встречи и полезен в нескольких проектах конвейера.

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

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

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

Большинство реализаций конкурентных коллекций (включая большинство очередей) также отличаются от обычных 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 транзитивно, все действия потока до разблокировки happen-before все действия, последующие после любой блокировки монитора этим потоком.
• Запись в поле volatile happens-before каждого последующего чтения этого же поля. Записи и чтения полей volatile имеют аналогичные эффекты согласованности памяти, как вход и выход из мониторов, но не подразумевают взаимную блокировку.
• Вызов start для потока happens-before любого действия в запущенном потоке.
• Все действия в потоке happen-before любого другого потока, успешно возвращающегося из 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 в других потоках.