Пакет 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 предоставляет фабричные методы для самых распространённых типов и конфигураций Executor, а также несколько утилитных методов для их использования. Другие утилиты, основанные на 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, когда ожидаемое число чтений и проходов намного превышает число обновлений в списке.

Префикс «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 в других потоках.