Класс StampedLock

public class StampedLock extends Object implements Serializable

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

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

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

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

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

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

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

Синхронизация памяти. Методы с эффектом успешной блокировки в любом режиме имеют те же эффекты синхронизации памяти, что и действие Lock, как описано в главе 17 спецификации языка Java. Методы, успешно разблокирующие запись, имеют те же эффекты синхронизации памяти, что и действие Unlock. При использовании оптимистического чтения действия до последнего действия разблокировки в режиме записи гарантированы для выполнения перед теми, что следуют за tryOptimisticRead, только если последующая проверка возвращает true; в противном случае нет гарантии, что чтения между tryOptimisticRead и validate получат согласованный снимок.

Пример использования. Следующий пример демонстрирует некоторые паттерны использования в классе, который поддерживает простые двумерные точки. Пример кода демонстрирует некоторые соглашения 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 moveIfAtOrigin2(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);
     }
   }
 }