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

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

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