Класс 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);
     }
   }
 }