Пакет java.util.concurrent.atomic

Маленький инструментарий классов, которые поддерживают ориентированное на многопотоковое исполнение программирование без блокировок на единственных переменных.

См.: Описание

Сводка класса

Класс	Описание
AtomicBoolean	A boolean значение, которое может быть обновлено атомарно.
AtomicInteger	int значение, которое может быть обновлено атомарно.
AtomicIntegerArray	int массив, в котором элементы могут быть обновлены атомарно.
AtomicIntegerFieldUpdater <T>	Основанная на отражении утилита, которая включает атомарным обновлениям к определяемому volatile int поля определяемых классов.
AtomicLong	A long значение, которое может быть обновлено атомарно.
AtomicLongArray	A long массив, в котором элементы могут быть обновлены атомарно.
AtomicLongFieldUpdater <T>	Основанная на отражении утилита, которая включает атомарным обновлениям к определяемому volatile long поля определяемых классов.
AtomicMarkableReference <V>	AtomicMarkableReference поддерживает ссылку на объект наряду с битом метки, который может быть обновлен атомарно.
AtomicReference <V>	Ссылка на объект, которая может быть обновлена атомарно.
AtomicReferenceArray <E>	Массив ссылок на объект, в которых элементы могут быть обновлены атомарно.
AtomicReferenceFieldUpdater <T, V>	Основанная на отражении утилита, которая включает атомарным обновлениям к определяемому volatile ссылочные поля определяемых классов.
AtomicStampedReference <V>	AtomicStampedReference поддерживает ссылку на объект наряду с целочисленным "штампом", который может быть обновлен атомарно.
DoubleAccumulator	Одна или более переменных, которые вместе поддерживают выполнение double оцените обновленное использование предоставленной функции.
DoubleAdder	Одна или более переменных, которые вместе поддерживают первоначально нуль double сумма.
LongAccumulator	Одна или более переменных, которые вместе поддерживают выполнение long оцените обновленное использование предоставленной функции.
LongAdder	Одна или более переменных, которые вместе поддерживают первоначально нуль long сумма.

Пакет java.util.concurrent.atomic Описание

Маленький инструментарий классов, которые поддерживают ориентированное на многопотоковое исполнение программирование без блокировок на единственных переменных. В основном классы в этом пакете расширяют понятие volatile значения, поля, и элементы массива тем, которые также обеспечивают атомарную условную работу обновления формы:

  boolean compareAndSet(expectedValue, updateValue);

Этот метод (который изменяется по типам параметра через различные классы) атомарно устанавливает переменную в updateValue если это в настоящий момент содержит expectedValue, создание отчетов true на успехе. Классы в этом пакете также содержат методы, чтобы получить и безоговорочно установить значения, так же как более слабую условную атомарную работу обновления weakCompareAndSet описанный ниже.

Спецификации этих методов позволяют реализациям использовать эффективные атомарные инструкции на уровне машины, которые доступны на современных процессорах. Однако на некоторых платформах, поддержка может повлечь за собой некоторую форму внутренней блокировки. Таким образом методы, как строго гарантируют, не неблокируют - поток может блокировать скоротечно прежде, чем выполнить работу.

Экземпляры классов AtomicBoolean, AtomicInteger, AtomicLong, и AtomicReference каждый обеспечивает доступ и обновления к единственной переменной соответствующего типа. Каждый class также обеспечивает соответствующие служебные методы для того типа. Например, классы AtomicLong и AtomicInteger обеспечьте атомарные методы инкремента. Одно приложение должно генерировать порядковые номера, как в:

 
 class Sequencer {
   private final AtomicLong sequenceNumber
     = new AtomicLong(0);
   public long next() {
     return sequenceNumber.getAndIncrement();
   }
 }

Это прямо, чтобы определить новые служебные функции это, как getAndIncrement, примените функцию к значению атомарно. Например, учитывая некоторое преобразование

  long transform(long input)

запишите свой служебный метод следующим образом:

 
 long getAndTransform(AtomicLong var) {
   while (true) {
     long current = var.get();
     long next = transform(current);
     if (var.compareAndSet(current, next))
         return current;
         // return next; for transformAndGet
   }
 }

Эффекты памяти для доступов и обновлений атомной энергетики обычно следуют за правилами для volatiles, как утверждено в Спецификации языка Java, Третьем Выпуске (17.4 Моделей памяти):

• get имеет эффекты памяти чтения a volatile переменная.
• set имеет эффекты памяти записи (присвоения) a volatile переменная.
• lazySet имеет эффекты памяти записи (присвоения) a volatile переменная за исключением того, что это разрешает переупорядочивания с последующим (но не предыдущее) действия памяти, которые самостоятельно не налагают ограничения переупорядочения с обычным не -volatile записи. Среди других контекстов использования, lazySet может применяться, обнуляя, ради сборки "мусора", ссылка, к которой никогда не получают доступ снова.
• weakCompareAndSet атомарно чтения и условно пишут переменную, но не создают, любой происходит - перед упорядочиваниями, так не обеспечивает гарантий относительно предыдущих или последующих чтений и записей любых переменных кроме цели weakCompareAndSet.
• compareAndSet и все другие операции чтения-и-обновления такой как getAndIncrement имейте эффекты памяти и чтения и записи volatile переменные.

В дополнение к классам, представляющим единственные значения, этот пакет содержит классы Updater, которые могут использоваться, чтобы получить compareAndSet операции на любом выбранном volatile поле любого выбрало class. AtomicReferenceFieldUpdater, AtomicIntegerFieldUpdater, и AtomicLongFieldUpdater основанные на отражении утилиты, которые обеспечивают доступ к связанным типам поля. Они имеют, главным образом, использование в атомарных структурах данных в который несколько volatile поля того же самого узла (например, ссылки древовидного узла) независимо подвергаются атомарным обновлениям. Эти классы включают большей гибкости в том, как и когда использовать атомарные обновления, за счет более неуклюжей основанной на отражении установки, менее удобного использования, и более слабых гарантий.

AtomicIntegerArray, AtomicLongArray, и AtomicReferenceArray классы далее расширяют атомарную поддержку работы массивам этих типов. Эти классы также известны в обеспечении volatile семантика доступа для их элементов массива, которая не поддерживается для обычных массивов.

Атомарные классы также поддерживают метод weakCompareAndSet, который ограничил применимость. На некоторых платформах слабая версия может быть более эффективной чем compareAndSet в нормальном случае, но отличается по тому любому данному вызову weakCompareAndSet метод может возвратиться false побочно (то есть, ни по какой очевидной причине). A false возвратите средства только, что работа может быть повторена при желании, полагаясь на гарантию, которая повторила вызов, когда переменная содержит expectedValue и никакой другой поток также не пытается установить переменную, в конечном счете успешно выполнится. (Такие побочные отказы могут например произойти из-за эффектов нехватки памяти, которые не связаны с тем, равна ли ожидаемая и текущая стоимость.) Дополнительно weakCompareAndSet не обеспечивает гарантии упорядочивания, которые обычно необходимы для управления синхронизацией. Однако, метод может быть полезным для обновления счетчиков и статистики, когда такие обновления не связаны с другим, происходит - перед упорядочиваниями программы. Когда поток видит обновление к атомарной переменной, вызванной a weakCompareAndSet, это не обязательно видит обновления к любым другим переменным, которые произошли перед weakCompareAndSet. Это может быть приемлемым когда, например, обновляя статистику производительности, но редко иначе.

AtomicMarkableReference class связывает сингл, булев к ссылке. Например, этот бит мог бы использоваться в структуре данных, чтобы означать, что ссылаемый объект был логически удален. AtomicStampedReference class связывает целочисленное значение со ссылкой. Это может использоваться например, чтобы представить соответствие номеров версий ряду обновлений.

Атомарные классы разрабатываются прежде всего как стандартные блоки для того, чтобы реализовать структуры данных неблокирования и связанные классы инфраструктуры. compareAndSet метод не является общей заменой для того, чтобы заблокировать. Это применяется только, когда критические обновления для объекта ограничиваются единственной переменной.

Атомарные классы не являются заменами общего назначения для java.lang.Integer и связанные классы. Они не определяют методы такой как hashCode и compareTo. (Поскольку атомарные переменные, как ожидают, будут видоизменены, они - плохие варианты для ключей хэш-таблицы.) Дополнительно, классы обеспечиваются только для тех типов, которые обычно полезны в применениях по назначению. Например, нет никакого атомарного class для того, чтобы представить byte. В тех нечастых случаях, где требуется сделать так, можно использовать AtomicInteger содержать byte значения, и бросок соответственно. Можно также содержать плавающее использование Float.floatToRawIntBits(float) и Float.intBitsToFloat(int) преобразования, и удваивают использование Double.doubleToRawLongBits(double) и Double.longBitsToDouble(long) преобразования.

С тех пор:

1.5