Класс AbstractQueuedSynchronizer

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements Serializable

Предоставляет инфраструктуру для реализации блокирующих блокировок и связанных с ними средств синхронизации (семафоров, событий и т. д.), использующих FIFO-очереди ожидания. Этот класс предназначен для использования в качестве основы для большинства видов средств синхронизации, которые полагаются на одно атомарное значение int для представления состояния. Подклассы должны определять защищённые методы, изменяющие это состояние и определяющие, что оно означает с точки зрения захвата или освобождения данного объекта. На этой основе остальные методы этого класса выполняют все операции постановки в очередь и блокировки. Подклассы могут поддерживать другие поля состояния, однако в отношении синхронизации отслеживается только атомарно обновляемое значение int, изменяемое с помощью методов getState(), setState(int) и compareAndSetState(int, int).

Подклассы следует объявлять как непубличные внутренние вспомогательные классы, используемые для реализации свойств синхронизации охватывающего их класса. Класс AbstractQueuedSynchronizer не реализует никаких интерфейсов синхронизации. Вместо этого он определяет такие методы, как acquireInterruptibly(int), которые конкретные блокировки и связанные с ними средства синхронизации могут вызывать по мере необходимости для реализации своих открытых методов.

Этот класс поддерживает один или оба режима: эксклюзивный режим по умолчанию и разделяемый режим. При захвате в эксклюзивном режиме попытки захвата со стороны других потоков не могут завершиться успешно. В разделяемом режиме захват несколькими потоками может завершиться успешно, но это не обязательно. Этот класс не «понимает» различий между этими режимами иначе, чем в механическом смысле: если попытка захвата в разделяемом режиме завершается успешно, следующий ожидающий поток (если он есть) также должен определить, может ли он выполнить захват. Ожидающие потоки в разных режимах используют одну FIFO-очередь. Обычно подклассы реализации поддерживают только один из этих режимов, однако оба режима могут использоваться, например, в ReadWriteLock. Подклассам, поддерживающим только эксклюзивный или только разделяемый режим, не нужно определять методы для неиспользуемого режима.

Этот класс определяет вложенный класс AbstractQueuedSynchronizer.ConditionObject, который может использоваться подклассами, поддерживающими эксклюзивный режим, в качестве реализации Condition, если метод isHeldExclusively() сообщает, удерживается ли блокировка синхронизации эксклюзивно текущим потоком, вызванный с текущим значением getState() метод release(int) полностью освобождает этот объект, а базовая версия acquire(int) в конечном счёте восстанавливает прежнее состояние захвата этого объекта, используя сохранённое значение состояния. Ни один метод AbstractQueuedSynchronizer не создаёт такое условие, поэтому не используйте его, если это ограничение не может быть выполнено. Поведение AbstractQueuedSynchronizer.ConditionObject, разумеется, зависит от семантики реализации средства синхронизации.

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

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

Использование

Чтобы использовать этот класс в качестве основы для средства синхронизации, переопределите следующие методы, если это применимо, проверяя и/или изменяя состояние синхронизации с помощью getState(), setState(int) и/или compareAndSetState(int, int):

• tryAcquire(int)
• tryRelease(int)
• tryAcquireShared(int)
• tryReleaseShared(int)
• isHeldExclusively()

По умолчанию каждый из этих методов выбрасывает исключение UnsupportedOperationException. Реализации этих методов должны быть потокобезопасными и, как правило, короткими и неблокирующими. Определение этих методов — единственный поддерживаемый способ использования данного класса. Все остальные методы объявлены как final, поскольку их нельзя изменять независимо.

Также могут оказаться полезными унаследованные методы из AbstractOwnableSynchronizer, позволяющие отслеживать поток, владеющий эксклюзивным средством синхронизации. Рекомендуется использовать эти методы: они позволяют средствам мониторинга и диагностики определять, какие потоки удерживают блокировки.

Хотя этот класс основан на внутренней FIFO-очереди, он не обеспечивает автоматически политику захвата FIFO. Основная часть эксклюзивной синхронизации выглядит следующим образом:

Acquire:
    while (!tryAcquire(arg)) {
       enqueue thread if it is not already queued;
       possibly block current thread;
    }

Release:
    if (tryRelease(arg))
       unblock the first queued thread;

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

Поскольку проверки при захвате выполняются до постановки в очередь, новый поток, пытающийся выполнить захват, может обойти другие заблокированные потоки, уже находящиеся в очереди. Однако при необходимости можно определить tryAcquire и/или tryAcquireShared, чтобы запретить обход, вызывая внутри один или несколько методов проверки и тем самым обеспечивая справедливый порядок захвата FIFO. В частности, большинство справедливых средств синхронизации могут определить tryAcquire так, чтобы он возвращал false, если hasQueuedPredecessors() (метод, специально предназначенный для использования справедливыми средствами синхронизации) возвращает true. Возможны и другие варианты.

Пропускная способность и масштабируемость обычно максимальны при использовании стратегии обхода по умолчанию (также называемой жадной, без отказа от борьбы и избегающей конвоев). Хотя такая стратегия не гарантирует справедливость или отсутствие голодания, потокам, раньше поставленным в очередь, разрешается повторно бороться за захват до более поздних потоков, и при каждой такой попытке у них есть равные шансы на успех по сравнению с вновь поступившими потоками. Кроме того, хотя при захвате в обычном смысле не выполняется «активное ожидание», перед блокировкой может производиться несколько вызовов tryAcquire, перемежающихся с другими вычислениями. Это обеспечивает большую часть преимуществ активного ожидания, когда эксклюзивная синхронизация удерживается лишь короткое время, не создавая при этом большей части сопутствующих проблем, если это не так. При желании это поведение можно дополнить проверками «быстрого пути» перед вызовами методов захвата, предварительно проверяя hasContended() и/или hasQueuedThreads(), чтобы выполнять их только в случае, когда средство синхронизации, вероятно, не испытывает конкуренции.

Этот класс обеспечивает эффективную и масштабируемую основу для синхронизации, в частности, ограничивая область применения средствами синхронизации, которые могут полагаться на состояние int, параметры захвата и освобождения и внутреннюю FIFO-очередь ожидания. Если этого недостаточно, можно создавать средства синхронизации на более низком уровне, используя классы atomic, собственные пользовательские классы Queue и средства блокировки LockSupport.

Примеры использования

Ниже приведён класс нерекурсивной блокировки взаимного исключения, в котором ноль обозначает незаблокированное состояние, а единица — заблокированное. Хотя нерекурсивная блокировка не требует строгой необходимости сохранять сведения о текущем потоке-владельце, этот класс делает это для упрощения мониторинга использования. Он также поддерживает условия и предоставляет некоторые методы инструментирования:

class Mutex implements Lock, java.io.Serializable {

  // Our internal helper class
  private static class Sync extends AbstractQueuedSynchronizer {
    // Acquires the lock if state is zero
    public boolean tryAcquire(int acquires) {
      assert acquires == 1; // Otherwise unused
      if (compareAndSetState(0, 1)) {
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
      }
      return false;
    }

    // Releases the lock by setting state to zero
    protected boolean tryRelease(int releases) {
      assert releases == 1; // Otherwise unused
      if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
      setExclusiveOwnerThread(null);
      setState(0);
      return true;
    }

    // Reports whether in locked state
    public boolean isLocked() {
      return getState() != 0;
    }

    public boolean isHeldExclusively() {
      // a data race, but safe due to out-of-thin-air guarantees
      return getExclusiveOwnerThread() == Thread.currentThread();
    }

    // Provides a Condition
    public Condition newCondition() {
      return new ConditionObject();
    }

    // Deserializes properly
    private void readObject(ObjectInputStream s)
        throws IOException, ClassNotFoundException {
      s.defaultReadObject();
      setState(0); // reset to unlocked state
    }
  }

  // The sync object does all the hard work. We just forward to it.
  private final Sync sync = new Sync();

  public void lock()              { sync.acquire(1); }
  public boolean tryLock()        { return sync.tryAcquire(1); }
  public void unlock()            { sync.release(1); }
  public Condition newCondition() { return sync.newCondition(); }
  public boolean isLocked()       { return sync.isLocked(); }
  public boolean isHeldByCurrentThread() {
    return sync.isHeldExclusively();
  }
  public boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
  }
  public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
  }
  public boolean tryLock(long timeout, TimeUnit unit)
      throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
  }
}

Ниже приведён класс защёлки, похожий на CountDownLatch, за исключением того, что для срабатывания ему требуется только один signal. Поскольку защёлка не является эксклюзивной, в ней используются методы захвата и освобождения shared.

class BooleanLatch {

  private static class Sync extends AbstractQueuedSynchronizer {
    boolean isSignalled() { return getState() != 0; }

    protected int tryAcquireShared(int ignore) {
      return isSignalled() ? 1 : -1;
    }

    protected boolean tryReleaseShared(int ignore) {
      setState(1);
      return true;
    }
  }

  private final Sync sync = new Sync();
  public boolean isSignalled() { return sync.isSignalled(); }
  public void signal()         { sync.releaseShared(1); }
  public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
  }
}