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

Блокировки ReentrantReadWrite могут использоваться для повышения конкурении в некоторых случаях использования некоторых типов коллекций. Это обычно стоит того только в том случае, если коллекции ожидаются большими, доступ к ним получают больше потоков-читателей, чем потоков-писателей, и операции требуют вычислений, которые перевешивают расходы на синхронизацию. Например, здесь представлен класс, использующий 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 в методах блокировки.