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