Класс ReentrantReadWriteLock

public class ReentrantReadWriteLock extends Object implements ReadWriteLock, Serializable

Реализация ReadWriteLock, поддерживающая семантику, аналогичную ReentrantLock.

Этот класс обладает следующими свойствами:

• Порядок получения

  Этот класс не устанавливает предпочтительный порядок доступа к блокировке для читателей или писателей. Однако он поддерживает необязательную политику справедливости.

  Несправедливый режим (по умолчанию)

  При создании в несправедливом режиме (по умолчанию) порядок получения блокировок чтения и записи не определен и зависит от ограничений реентерабельности. Несправедливая блокировка, за которую непрерывно конкурируют потоки, может неопределенно долго откладывать выполнение одного или нескольких потоков-читателей или потоков-писателей, но обычно обеспечивает более высокую пропускную способность, чем справедливая блокировка.

  Справедливый режим

  При создании в справедливом режиме потоки конкурируют за получение блокировки в приблизительном порядке поступления. Когда текущая блокировка освобождается, блокировка записи назначается либо потоку-писателю, который дольше всех ожидает, либо группе потоков-читателей, если она ожидает дольше всех потоков-писателей.

  Поток, пытающийся получить справедливую блокировку чтения (не реентерабельно), будет заблокирован, если удерживается блокировка записи или ожидает поток-писатель. Поток не получит блокировку чтения, пока самый давно ожидающий поток-писатель не получит и не освободит блокировку записи. Разумеется, если ожидающий писатель прекратит ожидание и в очереди останутся один или несколько потоков-читателей, ожидающих дольше остальных, а блокировка записи будет свободна, этим читателям будет назначена блокировка чтения.

  Поток, пытающийся получить справедливую блокировку записи (не реентерабельно), будет заблокирован, пока обе блокировки — чтения и записи — не освободятся (это означает, что ожидающих потоков нет). (Обратите внимание: неблокирующие методы ReentrantReadWriteLock.ReadLock.tryLock() и ReentrantReadWriteLock.WriteLock.tryLock() не учитывают эту настройку справедливости и немедленно получают блокировку, если это возможно, независимо от ожидающих потоков.)

• Реентерабельность

  Эта блокировка позволяет как читателям, так и писателям повторно получать блокировки чтения или записи по принципу ReentrantLock. Потоки-читатели, не являющиеся реентерабельными, не допускаются, пока пишущий поток не освободит все удерживаемые им блокировки записи.

  Кроме того, писатель может получить блокировку чтения, но не наоборот. Среди прочего, реентерабельность может быть полезна, когда блокировки записи удерживаются во время вызовов или обратных вызовов методов, выполняющих чтение под блокировками чтения. Если читатель попытается получить блокировку записи, ему это никогда не удастся.

  Примечание. Если вы не полагаетесь на реентерабельность, StampedLock может обеспечить более высокую производительность, например: ReadWriteLock lock = new StampedLock().asReadWriteLock().

• Понижение блокировки

  Реентерабельность также позволяет понизить блокировку записи до блокировки чтения: для этого нужно получить блокировку записи, затем блокировку чтения и после этого освободить блокировку записи. Однако повысить блокировку чтения до блокировки записи невозможно.

• Прерывание при получении блокировки

  Блокировки чтения и записи поддерживают прерывание во время получения блокировки.

• Поддержка Condition

  Блокировка записи предоставляет реализацию Condition, которая ведет себя в отношении блокировки записи так же, как реализация Condition, предоставляемая ReentrantLock.newCondition() для ReentrantLock. Разумеется, эту Condition можно использовать только с блокировкой записи.

  Блокировка чтения не поддерживает Condition, а readLock().newCondition() вызывает UnsupportedOperationException.

• Инструментирование

  Этот класс поддерживает методы для определения того, удерживаются ли блокировки или конкурируют ли за них потоки. Эти методы предназначены для мониторинга состояния системы, а не для управления синхронизацией.

Сериализация этого класса ведет себя так же, как у встроенных блокировок: десериализованная блокировка находится в разблокированном состоянии независимо от ее состояния на момент сериализации.

Примеры использования. Ниже приведен фрагмент кода, показывающий, как понизить блокировку после обновления кэша (обработка исключений особенно сложна при работе с несколькими блокировками без вложенной структуры):

class CachedData {
  Object data;
  boolean cacheValid;
  final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

  void processCachedData() {
    rwl.readLock().lock();
    // Code between the lock() above, and the unlock() below must not throw
    if (!cacheValid) {
      // Must release read lock before acquiring write lock
      rwl.readLock().unlock();
      rwl.writeLock().lock();
      try {
        // Recheck state because another thread might have
        // acquired write lock and changed state before we did.
        if (!cacheValid) {
          data = ...;
          cacheValid = true;
        }
        // Downgrade by acquiring read lock before releasing write lock
        rwl.readLock().lock();
      } finally {
        rwl.writeLock().unlock(); // Unlock write, still hold read
      }
    }
    // Make sure that code that could throw is executed inside the try block
    try {
      use(data);
    } finally {
      rwl.readLock().unlock();
    }
  }
}

ReentrantReadWriteLock можно использовать для повышения параллелизма в некоторых случаях работы с некоторыми видами коллекций. Обычно это имеет смысл только тогда, когда коллекции предположительно велики, к ним обращается больше потоков-читателей, чем потоков-писателей, а выполняемые операции достаточно затратны, чтобы накладные расходы на синхронизацию были оправданы. Например, ниже приведен класс, использующий TreeMap, которая предположительно велика и доступна из нескольких потоков.

class RWDictionary {
  private final Map<String, Data> m = new TreeMap<>();
  private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
  private final Lock r = rwl.readLock();
  private final Lock w = rwl.writeLock();

  public Data get(String key) {
    r.lock();
    try { return m.get(key); }
    finally { r.unlock(); }
  }
  public List<String> allKeys() {
    r.lock();
    try { return new ArrayList<>(m.keySet()); }
    finally { r.unlock(); }
  }
  public Data put(String key, Data value) {
    w.lock();
    try { return m.put(key, value); }
    finally { w.unlock(); }
  }
  public void clear() {
    w.lock();
    try { m.clear(); }
    finally { w.unlock(); }
  }
}

Примечания по реализации

Эта блокировка поддерживает не более Integer.MAX_VALUE рекурсивных блокировок записи и Integer.MAX_VALUE блокировок чтения. Попытки превысить эти пределы приводят к тому, что методы блокировки выбрасывают Error.