Класс StampedLock

public class StampedLock
extends Object
implements Serializable

Блокировка на основе возможностей с тремя режимами для управления чтением/записью. Состояние StampedLock состоит из версии и режима. Методы приобретения блокировки возвращают штамп, который представляет и управляет доступом относительно состояния блокировки; «попыточные» версии этих методов могут вместо этого вернуть специальное значение ноль, чтобы указать на неудачу в приобретении доступа. Методы освобождения и преобразования блокировки требуют штампов в качестве аргументов и завершаются неудачей, если они не соответствуют состоянию блокировки. Три режима следующие:

• Запись. Метод writeLock() может заблокироваться, ожидая эксклюзивного доступа, возвращая штамп, который может быть использован в методе unlockWrite(long) для освобождения блокировки. Также предоставляются неограниченные и ограниченные по времени версии tryWriteLock. Когда блокировка удерживается в режиме записи, получить блокировку чтения невозможно, и все оптимистичные проверки чтения завершатся неудачей.
• Чтение. Метод readLock() может заблокироваться, ожидая неэксклюзивного доступа, возвращая штамп, который может быть использован в методе unlockRead(long) для освобождения блокировки. Также предоставляются неограниченные и ограниченные по времени версии tryReadLock.
• Оптимистическое чтение. Метод tryOptimisticRead() возвращает ненулевой штамп только в том случае, если блокировка в данный момент не удерживается в режиме записи. Метод validate(long) возвращает true, если блокировка не была приобретена в режиме записи с момента получения заданного штампа. Этот режим можно рассматривать как чрезвычайно слабую версию блокировки чтения, которая может быть прервана записывающим потоком в любое время. Использование оптимистического режима для коротких участков кода только для чтения часто уменьшает конфликтность и улучшает пропускную способность. Однако его использование изначально хрупко. Участки кода оптимистического чтения должны только читать поля и удерживать их в локальных переменных для последующего использования после проверки. Поля, прочитанные в оптимистическом режиме, могут быть сильно несовместимы, поэтому использование применимо только в том случае, если вы достаточно хорошо знакомы с представлениями данных для проверки согласованности и/или многократного вызова метода validate(). Например, такие шаги обычно необходимы при первоначальном чтении ссылки на объект или массив, а затем обращении к одному из его полей, элементов или методов.

Этот класс также поддерживает методы, которые условно предоставляют преобразования между тремя режимами. Например, метод tryConvertToWriteLock(long) пытается «обновить» режим, возвращая допустимый штамп записи, если (1) уже в режиме записи (2) в режиме чтения и нет других читателей или (3) в оптимистическом режиме и блокировка доступна. Формы этих методов разработаны для снижения некоторых избыточных кодов, которые в противном случае возникают в проектах, основанных на повторных попытках.

StampedLocks разработаны для использования в качестве внутренних утилит при разработке потокобезопасных компонентов. Их использование основано на знании внутренних свойств данных, объектов и методов, которые они защищают. Они не являются реентерабельными, поэтому блокируемые участки кода не должны вызывать другие неизвестные методы, которые могут пытаться повторно получить блокировки (хотя вы можете передать штамп другим методам, которые могут его использовать или преобразовать). Использование режимов блокировки чтения основано на том, что связанные участки кода не имеют побочных эффектов. Непроверенные участки оптимистического чтения не могут вызывать методы, которые не известны как способные переносить потенциальные несоответствия. Штампы используют конечные представления и не являются криптографически защищенными (т. е. допустимый штамп может быть угадан). Значения штампов могут перерабатываться через (не раньше) год непрерывной работы. Штамп, удерживаемый без использования или проверки в течение более длительного периода, может не пройти проверку. StampedLocks сериализуемы, но всегда десериализуются в начальное разблокированное состояние, поэтому они не подходят для удалённой блокировки.

Как и Semaphore, но в отличие от большинства реализаций Lock, StampedLocks не имеют понятия владения. Блокировки, полученные в одном потоке, могут быть освобождены или преобразованы в другом.

Политика планирования StampedLock не всегда отдаёт предпочтение читателям перед записывающими потоками или наоборот. Все методы «попытки» — это попытка, и они не обязательно соответствуют какой-либо политике планирования или справедливости. Возврат нуля от любого метода «попытки» для приобретения или преобразования блокировок не несёт никакой информации о состоянии блокировки; последующий вызов может быть успешным.

Поскольку он поддерживает скоординированное использование по нескольким режимам блокировки, этот класс не реализует напрямую интерфейсы Lock или ReadWriteLock. Однако в приложениях, требующих только соответствующего набора функциональности, StampedLock можно рассматривать как asReadLock(), asWriteLock() или asReadWriteLock().

Пример использования. Следующее иллюстрирует некоторые шаблоны использования в классе, который поддерживает простые двухмерные точки. Пример кода иллюстрирует некоторые соглашения try/catch, хотя они здесь строго не нужны, поскольку исключения не могут произойти в их телах.

class Point {
   private double x, y;
   private final StampedLock sl = new StampedLock();

   // an exclusively locked method
   void move(double deltaX, double deltaY) {
     long stamp = sl.writeLock();
     try {
       x += deltaX;
       y += deltaY;
     } finally {
       sl.unlockWrite(stamp);
     }
   }

   // a read-only method
   // upgrade from optimistic read to read lock
   double distanceFromOrigin() {
     long stamp = sl.tryOptimisticRead();
     try {
       retryHoldingLock: for (;; stamp = sl.readLock()) {
         if (stamp == 0L)
           continue retryHoldingLock;
         // possibly racy reads
         double currentX = x;
         double currentY = y;
         if (!sl.validate(stamp))
           continue retryHoldingLock;
         return Math.hypot(currentX, currentY);
       }
     } finally {
       if (StampedLock.isReadLockStamp(stamp))
         sl.unlockRead(stamp);
     }
   }

   // upgrade from optimistic read to write lock
   void moveIfAtOrigin(double newX, double newY) {
     long stamp = sl.tryOptimisticRead();
     try {
       retryHoldingLock: for (;; stamp = sl.writeLock()) {
         if (stamp == 0L)
           continue retryHoldingLock;
         // possibly racy reads
         double currentX = x;
         double currentY = y;
         if (!sl.validate(stamp))
           continue retryHoldingLock;
         if (currentX != 0.0 || currentY != 0.0)
           break;
         stamp = sl.tryConvertToWriteLock(stamp);
         if (stamp == 0L)
           continue retryHoldingLock;
         // exclusive access
         x = newX;
         y = newY;
         return;
       }
     } finally {
       if (StampedLock.isWriteLockStamp(stamp))
         sl.unlockWrite(stamp);
     }
   }

   // Upgrade read lock to write lock
   void moveIfAtOrigin(double newX, double newY) {
     long stamp = sl.readLock();
     try {
       while (x == 0.0 && y == 0.0) {
         long ws = sl.tryConvertToWriteLock(stamp);
         if (ws != 0L) {
           stamp = ws;
           x = newX;
           y = newY;
           break;
         }
         else {
           sl.unlockRead(stamp);
           stamp = sl.writeLock();
         }
       }
     } finally {
       sl.unlock(stamp);
     }
   }
 }