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

     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 при вызове методов блокировки.