Класс StampedLock

public class StampedLock extends Object implements Serializable

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

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

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

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

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

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

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

Синхронизация памяти. Методы, успешно блокирующие в любом режиме, имеют те же эффекты синхронизации памяти, что и действие Lock, описанное в главе 17 Спецификации языка Java. Методы, успешно освобождающие блокировку в режиме записи, имеют те же эффекты синхронизации памяти, что и действие Unlock. При использовании оптимистичного чтения действия, предшествующие последнему действию освобождения блокировки в режиме записи, гарантированно происходят до действий, следующих за tryOptimisticRead, только если последующий вызов validate возвращает 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);
    }
  }
}