Класс ReentrantReadWriteLock

public class ReentrantReadWriteLock extends Object implements ReadWriteLock, Serializable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• Поддержка 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.