Класс StampedLock

public class StampedLock extends Object implements Serializable

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

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