Класс StampedLock

public class StampedLock extends Object implements Serializable

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

• Запись. Метод writeLock() возможно, блокируется, ожидая исключительного доступа, возвращая штамп, который может быть использован в методе unlockWrite(long) для освобождения замка. Также предоставлены неуточнённые и ограниченные по времени версии tryWriteLock. Когда замок удерживается в режиме записи, никакие чтение замки не могут быть получены, и все оптимистичные проверки чтения завершатся неудачей.
• Чтение. Метод readLock() возможно, блокируется, ожидая неисключительного доступа, возвращая штамп, который может быть использован в методе unlockRead(long) для освобождения замка. Также предоставлены неуточнённые и ограниченные по времени версии tryReadLock.
• Оптимистичное чтение. Метод tryOptimisticRead() возвращает ненулевой штамп только в том случае, если замок в настоящее время не удерживается в режиме записи. Метод validate(long) возвращает true, если замок не был получен в режиме записи с момента получения данного штампа, в этом случае все действия до последнего освобождения записи lock происходят до действий, следующих за вызовом 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);
     }
   }
 }