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

Коллекции для параллельной работы

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

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

Большинство реализаций параллельных Collection (включая большинство очередей) также отличаются от обычных соглашений 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 и его подпакетах распространяют эти гарантии на синхронизацию более высокого уровня. В частности:

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