モジュール java.base

クラスAbstractQueuedSynchronizer

  • すべての実装されたインタフェース:
    Serializable

    public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements Serializable
    ブロック・ロック、および先入れ先出し(FIFO)待機キューに依存する関連シンクロナイザ(セマフォ、イベントなど)を実装するフレームワークを提供します。 このクラスは、状態表現を単一の原子int値に依存する大半の種類のシンクロナイザの有用な基盤として設計されています。 サブクラスは、この状態を変更するprotectedメソッドを定義する必要があり、そのメソッドは取得または解放中のオブジェクトを使用して状態の意味を定義します。 これらが指定されると、このクラス内のほかのメソッドはすべてのキューおよびブロック機構を稼働させます。 サブクラスは、ほかの状態フィールドを維持できますが、同期に関する追跡を行えるのはgetState()setState(int)、およびcompareAndSetState(int, int)メソッドを使用して操作され、原子的に更新されたint値だけです。

    サブクラスは、publicではない内部ヘルパー・クラスとして定義する必要があります。これは、それを囲むクラスの同期プロパティの実装に使用されます。 AbstractQueuedSynchronizerクラスは、同期インタフェースを一切実装しません。 かわりに、具象ロックおよび関連するシンクロナイザにより適宜呼び出してpublicメソッドを実装できるacquireInterruptibly(int)などのメソッドを定義します。

    このクラスは、デフォルトの排他モードと共有モードのどちらかまたは両方をサポートします。 排他モードで取得されると、ほかのスレッドが取得を試みても成功しません。 共有モードでは、複数のスレッドによる取得が可能です(ただし、必ず取得が成功する必要があるわけではない)。 このクラスは、共有モードの取得が成功した場合、待機中の次のスレッド(存在する場合)も取得可能かどうかを判別する必要があるという機構的な意味を除き、これらの違いを認識しません。 別のモードで待機中のスレッドは、同じFIFOキューを共有します。 通常、実装サブクラスはこれらのモードの1つだけをサポートしますが、ReadWriteLockなどでは両方が機能することが可能です。 排他モードまたは共有モードのみをサポートするサブクラスは、使用しないモードをサポートするメソッドを定義する必要はありません。

    このクラスは、排他モードをサポートするサブクラスがCondition実装として使用できる、入れ子にされたAbstractQueuedSynchronizer.ConditionObjectクラスを定義します。これに関して、isHeldExclusively()メソッドは現在のスレッドに関して同期が排他的に保持されるかどうかを報告し、現在のgetState()値を使用して呼び出されたrelease(int)メソッドはこのオブジェクトを完全に解放し、さらにacquire(int)は、この保存された状態値が指定されると、このオブジェクトを以前の取得された状態に最終的に復元します。 それ以外では、どのAbstractQueuedSynchronizerメソッドもこのような状態を作成しないため、この制約を満たすことができない場合は使用しないでください。 AbstractQueuedSynchronizer.ConditionObjectの動作はもちろん、そのシンクロナイザ実装のセマンティックスに依存します。

    このクラスは、内部キューの検証、計測、および監視用メソッド、および状態オブジェクト用の類似メソッドを提供します。 これらは、必要に応じて、その同期機構のためのAbstractQueuedSynchronizerを使用してクラス内にエクスポートできます。

    このクラスを直列化すると、基になる原子整数の保守状態だけが格納されるため、直列化復元されたオブジェクトは空のスレッド・キューを保持します。 直列化可能性が必要な標準的なサブクラスは、直列化復元時にこれを既知の初期状態に復元するreadObjectメソッドを定義します。

    使用法

    このクラスをシンクロナイザの基盤として使用するには、必要に応じて、getState()setState(int)、またはcompareAndSetState(int, int)を使用して同期状態を検査または変更することによって次のメソッドを再定義します。

    これらの各メソッドは、デフォルトでは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;
     
    (共有モードも似ているが、カスケード信号が関係する場合がある)

    取得でのチェックはキューに入れられる前に呼び出されるため、新しく取得するスレッドは、ブロックされてキューに入れられる他のスレッドより先にバージできます。 ただし、必要であれば、tryAcquiretryAcquireSharedを定義して、1つ以上の検査メソッドを内部的に呼び出し、公平なFIFO取得順序を提供することによってバージを無効にするようにできます。 特に、ほとんどの公平なシンクロナイザは、hasQueuedPredecessors() (公平なシンクロナイザで使用されるように特別に設計されたメソッド)がtrueを返す場合はfalseを返すようにtryAcquireを定義できます。 その他のバリエーションも可能です。

    通常、スループットとスケーラビリティは、デフォルトのバージ(貪欲放棄護送回避とも呼ばれる)ストラテジの最上位に位置します。 これが偏りがなく、枯渇しないことは保証されませんが、先にキューに入れられたスレッドは、あとでキューに入れられるスレッドより前に再競合が許可され、各再競合は着信するスレッドに対して成功する公平な機会を保持します。 また、取得は、通常の意味ではスピンしませんが、ブロッキング前に他の計算に挿入された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));
       }
     }

    次に、起動に単一のsignalを必要とすることを除き、CountDownLatchクラスに類似したラッチ・クラスを示します。 ラッチは非排他的であるため、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);
       }
     }

    導入されたバージョン:
    1.5
    関連項目:
    直列化された形式
    • コンストラクタのサマリー

      コンストラクタ 
      修飾子 コンストラクタ 説明
      protected AbstractQueuedSynchronizer()
      ゼロの初期同期状態を使用して、新規AbstractQueuedSynchronizerインスタンスを作成します。
    • メソッドのサマリー

      すべてのメソッド インスタンス・メソッド 具象メソッド 
      修飾子と型 メソッド 説明
      void acquire​(int arg)
      割込みを無視して、排他モードで取得します。
      void acquireInterruptibly​(int arg)
      排他モードで取得します。割込みが発生した場合は、中止します。
      void acquireShared​(int arg)
      割込みを無視して、共有モードで取得します。
      void acquireSharedInterruptibly​(int arg)
      共有モードで取得します。
      protected boolean compareAndSetState​(int expect, int update)
      現在の状態値が予想される値に等しい場合、同期状態を指定された更新値に原子的に設定します。
      Collection<Thread> getExclusiveQueuedThreads()
      排他モードで取得するために待機中のスレッドを含むコレクションを返します。
      Thread getFirstQueuedThread()
      キュー内の最初の(待機時間のもっとも長い)スレッドを返します。現在キューにスレッドが入っていない場合はnullを返します。
      Collection<Thread> getQueuedThreads()
      パーミットの取得を待機しているスレッドを含むコレクションを返します。
      int getQueueLength()
      パーミットの取得を待機しているスレッドの推定数を返します。
      Collection<Thread> getSharedQueuedThreads()
      共有モードで取得するために待機中のスレッドを含むコレクションを返します。
      protected int getState()
      同期状態の現在値を返します。
      Collection<Thread> getWaitingThreads​(AbstractQueuedSynchronizer.ConditionObject condition)
      このシンクロナイザに関連付けられた指定の状態で待機中のスレッドを含むコレクションを返します。
      int getWaitQueueLength​(AbstractQueuedSynchronizer.ConditionObject condition)
      このシンクロナイザに関連付けられた指定の状態で待機しているスレッドの推定数を返します。
      boolean hasContended()
      このシンクロナイザを取得しようとしているスレッドがあるかどうかを問い合わせます; つまり、取得メソッドがブロックされている場合です。
      boolean hasQueuedPredecessors()
      現在のスレッドより長いスレッドを待機中のスレッドが存在するかどうかを紹介します。
      boolean hasQueuedThreads()
      パーミットの取得を待機中のスレッドが存在するかどうかを照会します。
      boolean hasWaiters​(AbstractQueuedSynchronizer.ConditionObject condition)
      このシンクロナイザに関連付けられた指定の状態で待機しているスレッドが存在するかどうかを照会します。
      protected boolean isHeldExclusively()
      現在の(呼出し側の)スレッドに関して、同期が排他的に行われる場合はtrueを返します。
      boolean isQueued​(Thread thread)
      指定されたスレッドが、現在キューに入っている場合はtrueを返します。
      boolean owns​(AbstractQueuedSynchronizer.ConditionObject condition)
      指定されたConditionObjectがこのシンクロナイザをロックとして使用するかどうかを照会します。
      boolean release​(int arg)
      排他モードで解放します。
      boolean releaseShared​(int arg)
      共有モードで解放します。
      protected void setState​(int newState)
      同期状態の値を設定します。
      String toString()
      シンクロナイザおよびその状態を識別する文字列を返します。
      protected boolean tryAcquire​(int arg)
      排他モードでの取得を試みます。
      boolean tryAcquireNanos​(int arg, long nanosTimeout)
      排他モードで取得を試みます。割込みが発生した場合は中止し、指定されたタイム・アウト時間が経過した場合は失敗します。
      protected int tryAcquireShared​(int arg)
      共有モードでの取得を試みます。
      boolean tryAcquireSharedNanos​(int arg, long nanosTimeout)
      共有モードで取得を試みます。割込みが発生した場合は中止し、指定されたタイム・アウト時間が経過した場合は失敗します。
      protected boolean tryRelease​(int arg)
      排他モードでの解放を反映するように、状態の設定を試みます。
      protected boolean tryReleaseShared​(int arg)
      共有モードでの解放を反映するように、状態の設定を試みます。
    • コンストラクタの詳細

      • AbstractQueuedSynchronizer

        protected AbstractQueuedSynchronizer()
        ゼロの初期同期状態を使用して、新規AbstractQueuedSynchronizerインスタンスを作成します。
    • メソッドの詳細

      • getState

        protected final int getState()
        同期状態の現在値を返します。 この操作は、volatile読込みのメモリー・セマンティクスを保持します。
        戻り値:
        現在の状態値
      • setState

        protected final void setState​(int newState)
        同期状態の値を設定します。 この操作は、volatile書込みのメモリー・セマンティクスを保持します。
        パラメータ:
        newState - 新規状態値
      • compareAndSetState

        protected final boolean compareAndSetState​(int expect,
                                                   int update)
        現在の状態値が予想される値に等しい場合、同期状態を指定された更新値に原子的に設定します。 この操作は、volatile読み込みおよび書込みのメモリー・セマンティクスを保持します。
        パラメータ:
        expect - 予想される値
        update - 新しい値
        戻り値:
        成功する場合はtrue falseは、実際の値が予想される値と等価ではないことを示す。
      • tryAcquire

        protected boolean tryAcquire​(int arg)
        排他モードでの取得を試みます。 このメソッドは、オブジェクトが排他モードでの取得を許可する状態にあるかどうかを照会し、許可する状態にあれば取得します。

        このメソッドは常に取得を実行するスレッドにより呼び出されます。 このメソッドが失敗をレポートし、かつスレッドがキューに入れられていない場合、取得メソッドは、ほかのスレッドからの解放により信号が送信されるまでそのスレッドをキューに入れることができます。 これは、Lock.tryLock()メソッドの実装に使用できます。

        デフォルト実装は、UnsupportedOperationExceptionをスローします。

        パラメータ:
        arg - acquireの引数。 この値は、常にacquireメソッドに渡される値、または状態待機へのエントリで保存される値になる。 それ以外の場合、この値は未解釈となり、任意の値を表すことができる。
        戻り値:
        成功する場合はtrue 成功時には、このオブジェクトは取得済みである。
        例外:
        IllegalMonitorStateException - 取得により、このシンクロナイザが不正な状態に置かれる場合。 同期が正しく機能するためには、この例外を一貫した方式でスローする必要がある。
        UnsupportedOperationException - 排他モードがサポートされていない場合
      • tryRelease

        protected boolean tryRelease​(int arg)
        排他モードでの解放を反映するように、状態の設定を試みます。

        このメソッドは、解放を実行するスレッドにより常に呼び出されます。

        デフォルト実装は、UnsupportedOperationExceptionをスローします。

        パラメータ:
        arg - releaseの引数。 この値は、常にreleaseメソッドに渡される値、または状態待機へのエントリでの現在の状態値になる。 それ以外の場合、この値は未解釈となり、任意の値を表すことができる。
        戻り値:
        待機中の任意のスレッドが取得を試みることができるように、このオブジェクトが完全に解放された状態にある場合はtrue、そうでない場合はfalse
        例外:
        IllegalMonitorStateException - 解放により、このシンクロナイザが不正な状態に置かれる場合。 同期が正しく機能するためには、この例外を一貫した方式でスローする必要がある。
        UnsupportedOperationException - 排他モードがサポートされていない場合
      • tryAcquireShared

        protected int tryAcquireShared​(int arg)
        共有モードでの取得を試みます。 このメソッドは、オブジェクトが共有モードでの取得を許可する状態にあるかどうかを照会し、許可する状態にあれば取得します。

        このメソッドは常に取得を実行するスレッドにより呼び出されます。 このメソッドが失敗をレポートし、かつスレッドがキューに入れられていない場合、取得メソッドは、ほかのスレッドからの解放により信号が送信されるまでそのスレッドをキューに入れることができます。

        デフォルト実装は、UnsupportedOperationExceptionをスローします。

        パラメータ:
        arg - acquireの引数。 この値は、常にacquireメソッドに渡される値、または状態待機へのエントリで保存される値になる。 それ以外の場合、この値は未解釈となり、任意の値を表すことができる。
        戻り値:
        失敗した場合は負の値。共有モードでの取得に成功したが、以後の共有モードでの取得に成功しない場合はゼロ。共有モードでの取得に成功し、以後の共有モードでの取得にも成功する可能性がある場合は正の値。正の値の場合、以後の待機スレッドで利用可能性をチェックする必要がある。 (3つの異なる戻り値のサポートにより、取得だけが時折排他的に動作するコンテキスト内でこのメソッドを使用することが可能になる。) 成功時には、このオブジェクトは取得済みである。
        例外:
        IllegalMonitorStateException - 取得により、このシンクロナイザが不正な状態に置かれる場合。 同期が正しく機能するためには、この例外を一貫した方式でスローする必要がある。
        UnsupportedOperationException - 共有モードがサポートされていない場合
      • tryReleaseShared

        protected boolean tryReleaseShared​(int arg)
        共有モードでの解放を反映するように、状態の設定を試みます。

        このメソッドは、解放を実行するスレッドにより常に呼び出されます。

        デフォルト実装は、UnsupportedOperationExceptionをスローします。

        パラメータ:
        arg - releaseの引数。 この値は、常にreleaseメソッドに渡される値、または状態待機へのエントリでの現在の状態値になる。 それ以外の場合、この値は未解釈となり、任意の値を表すことができる。
        戻り値:
        このリリースの共有モードで待機中の取得(共有または排他)を許可できる場合はtrue、そうでない場合はfalse
        例外:
        IllegalMonitorStateException - 解放により、このシンクロナイザが不正な状態に置かれる場合。 同期が正しく機能するためには、この例外を一貫した方式でスローする必要がある。
        UnsupportedOperationException - 共有モードがサポートされていない場合
      • isHeldExclusively

        protected boolean isHeldExclusively()
        現在の(呼出し側の)スレッドに関して、同期が排他的に行われる場合はtrueを返します。 このメソッドは、AbstractQueuedSynchronizer.ConditionObjectメソッドを呼び出すたびに呼び出されます。

        デフォルト実装は、UnsupportedOperationExceptionをスローします。 このメソッドは、AbstractQueuedSynchronizer.ConditionObjectメソッドで内部的にのみ呼び出されるため、状態が使用されない場合は定義する必要がありません。

        戻り値:
        同期が排他的に行われる場合はtrue、そうでない場合はfalse
        例外:
        UnsupportedOperationException - 状態がサポートされない場合
      • acquire

        public final void acquire​(int arg)
        割込みを無視して、排他モードで取得します。 一度以上tryAcquire(int)を呼び出すことで実装され、成功時に復帰します。 それ以外の場合、スレッドはキューに入れられ、たいていの場合ブロックおよびブロック解除を何度も繰り返し、成功するまでtryAcquire(int)を呼び出します。 このメソッドは、Lock.lock()メソッドの実装に使用できます。
        パラメータ:
        arg - acquireの引数。 この値はtryAcquire(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
      • acquireInterruptibly

        public final void acquireInterruptibly​(int arg)
                                        throws InterruptedException
        排他モードで取得します。割込みが発生した場合は、中止します。 最初に割込みステータスをチェックしてから一度以上tryAcquire(int)を呼び出すことで実装され、成功時に復帰します。 それ以外の場合、スレッドはキューに入れられ、たいていの場合ブロックおよびブロック解除を何度も繰り返し、成功するかスレッドで割込みが発生するまでtryAcquire(int)を呼び出します。 このメソッドは、Lock.lockInterruptibly()メソッドの実装に使用できます。
        パラメータ:
        arg - acquireの引数。 この値はtryAcquire(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
        例外:
        InterruptedException - 現在のスレッドで割込みが発生した場合
      • tryAcquireNanos

        public final boolean tryAcquireNanos​(int arg,
                                             long nanosTimeout)
                                      throws InterruptedException
        排他モードで取得を試みます。割込みが発生した場合は中止し、指定されたタイム・アウト時間が経過した場合は失敗します。 最初に割込みステータスをチェックしてから一度以上tryAcquire(int)を呼び出すことで実装され、成功時に復帰します。 それ以外の場合、スレッドはキューに入れられ、たいていの場合ブロックおよびブロック解除を何度も繰り返し、成功するかスレッドで割込みが発生するかタイムアウト時間が経過するまでtryAcquire(int)を呼び出します。 このメソッドは、Lock.tryLock(long, TimeUnit)メソッドの実装に使用できます。
        パラメータ:
        arg - acquireの引数。 この値はtryAcquire(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
        nanosTimeout - 待機する最大ナノ秒数
        戻り値:
        取得した場合はtrue、タイム・アウトした場合はfalse
        例外:
        InterruptedException - 現在のスレッドで割込みが発生した場合
      • release

        public final boolean release​(int arg)
        排他モードで解放します。 tryRelease(int)がtrueを返す場合、1つ以上のスレッドをブロック解除することで実装されます。 このメソッドは、Lock.unlock()メソッドの実装に使用できます。
        パラメータ:
        arg - releaseの引数。 この値はtryRelease(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
        戻り値:
        tryRelease(int)から返される値
      • acquireShared

        public final void acquireShared​(int arg)
        割込みを無視して、共有モードで取得します。 最初に一度以上tryAcquireShared(int)を呼び出すことで実装され、成功時に復帰します。 それ以外の場合、スレッドはキューに入れられ、たいていの場合ブロックおよびブロック解除を何度も繰り返し、成功するまでtryAcquireShared(int)を呼び出します。
        パラメータ:
        arg - acquireの引数。 この値はtryAcquireShared(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
      • acquireSharedInterruptibly

        public final void acquireSharedInterruptibly​(int arg)
                                              throws InterruptedException
        共有モードで取得します。 最初に割込みステータスをチェックしてから一度以上tryAcquireShared(int)を呼び出すことで実装され、成功時に復帰します。 それ以外の場合、スレッドはキューに入れられ、たいていの場合ブロックおよびブロック解除を何度も繰り返し、成功するかスレッドで割込みが発生するまでtryAcquireShared(int)を呼び出します。
        パラメータ:
        arg - acquireの引数。 この値はtryAcquireShared(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
        例外:
        InterruptedException - 現在のスレッドで割込みが発生した場合
      • tryAcquireSharedNanos

        public final boolean tryAcquireSharedNanos​(int arg,
                                                   long nanosTimeout)
                                            throws InterruptedException
        共有モードで取得を試みます。割込みが発生した場合は中止し、指定されたタイム・アウト時間が経過した場合は失敗します。 最初に割込みステータスをチェックしてから一度以上tryAcquireShared(int)を呼び出すことで実装され、成功時に復帰します。 それ以外の場合、スレッドはキューに入れられ、たいていの場合ブロックおよびブロック解除を何度も繰り返し、成功するかスレッドで割込みが発生するかタイムアウト時間が経過するまでtryAcquireShared(int)を呼び出します。
        パラメータ:
        arg - acquireの引数。 この値はtryAcquireShared(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
        nanosTimeout - 待機する最大ナノ秒数
        戻り値:
        取得した場合はtrue、タイム・アウトした場合はfalse
        例外:
        InterruptedException - 現在のスレッドで割込みが発生した場合
      • releaseShared

        public final boolean releaseShared​(int arg)
        共有モードで解放します。 tryReleaseShared(int)がtrueを返す場合、1つ以上のスレッドをブロック解除することで実装されます。
        パラメータ:
        arg - releaseの引数。 この値はtryReleaseShared(int)に送信されるが、それ以外の場合は未解釈となり、任意の値を表すことができる。
        戻り値:
        tryReleaseShared(int)から返される値
      • hasQueuedThreads

        public final boolean hasQueuedThreads()
        パーミットの取得を待機中のスレッドが存在するかどうかを照会します。 いずれかの時点で割り込みおよびタイム・アウトによる取消しが発生した場合、trueが返されてもほかのスレッドが取得を実行することは保証されません。
        戻り値:
        取得を待機中のほかのスレッドが存在する可能性がある場合はtrue
      • hasContended

        public final boolean hasContended()
        このシンクロナイザを取得しようとしているスレッドがあるかどうかを問い合わせます; つまり、取得メソッドがブロックされている場合です。

        この実装では、この操作は一定の時間で復帰します。

        戻り値:
        競合が存在する場合はtrue
      • getFirstQueuedThread

        public final Thread getFirstQueuedThread()
        キュー内の最初の(待機時間のもっとも長い)スレッドを返します。現在キューにスレッドが入っていない場合はnullを返します。

        通常、この実装では、この操作は一定時間で復帰します。ただし、ほかのスレッドがキューの変更を並行して実行している場合は、競合により処理を繰り返す場合があります。

        戻り値:
        キュー内の最初の(待機時間のもっとも長い)スレッド。現在キューにスレッドが入っていない場合はnull
      • isQueued

        public final boolean isQueued​(Thread thread)
        指定されたスレッドが、現在キューに入っている場合はtrueを返します。

        この実装は、キューをトラバースして指定されたスレッドの存在を判別します。

        パラメータ:
        thread - スレッド
        戻り値:
        指定されたスレッドがキューに入っている場合はtrue
        例外:
        NullPointerException - スレッドがnullの場合
      • hasQueuedPredecessors

        public final boolean hasQueuedPredecessors()
        現在のスレッドより長いスレッドを待機中のスレッドが存在するかどうかを紹介します。

        このメソッドの呼出しは、次と同等です(ただし、効率的である場合があります)。

         
         getFirstQueuedThread() != Thread.currentThread()
           && hasQueuedThreads()

        いずれかの時点で割り込みおよびタイム・アウトによる取消しが発生した場合、trueが返されても、ほかのスレッドが現在のスレッドよりも前に取得を実行することは保証されません。 同様に、このメソッドがfalseを返したあと、キューが空であることが原因で、別のスレッドがエンキューの競争に勝つ可能性もあります。

        このメソッドは、バージ(barging) を回避するために公平なシンクロナイザによって使用されるためのものです。 そのようなシンクロナイザのtryAcquire(int)メソッドはfalseを返し、このメソッドがtrueを返す場合、そのtryAcquireShared(int)メソッドは負の値を返すはずです(これが再入可能な取得である場合を除く)。 たとえば、公平で再入可能な排他モードのシンクロナイザの tryAcquireメソッドは、次のようになります。

         
         protected boolean tryAcquire(int arg) {
           if (isHeldExclusively()) {
             // A reentrant acquire; increment hold count
             return true;
           } else if (hasQueuedPredecessors()) {
             return false;
           } else {
             // try to acquire normally
           }
         }

        戻り値:
        現在のスレッドよりも前にキューに入れられたスレッドがある場合はtrue、現在のスレッドがキューの先頭にあるか、キューが空の場合はfalse
        導入されたバージョン:
        1.7
      • getQueueLength

        public final int getQueueLength()
        パーミットの取得を待機しているスレッドの推定数を返します。 このメソッドが内部のデータ構造をトラバースしている間にも、スレッド数が動的に変化する場合があるため、この値は推定に過ぎません。 このメソッドは、同期の制御用としてではなく、システム状態の監視用として設計されています。
        戻り値:
        取得を待機しているスレッドの推定数
      • getQueuedThreads

        public final Collection<Thread> getQueuedThreads()
        パーミットの取得を待機しているスレッドを含むコレクションを返します。 実際のスレッド・セットは、結果の構築中にも動的に変化する可能性があるため、返されるコレクションは最善の努力を払った上での推定に過ぎません。 返されるコレクションの要素には、特定の順序は存在しません。 このメソッドは、より包括的な監視機能を提供するサブクラスの構築を容易にする目的で設計されています。
        戻り値:
        スレッドのコレクション
      • getExclusiveQueuedThreads

        public final Collection<Thread> getExclusiveQueuedThreads()
        排他モードで取得するために待機中のスレッドを含むコレクションを返します。 これは、排他的取得のために待機中のスレッドのみを返すことを除いては、getQueuedThreads()と同じプロパティを保持します。
        戻り値:
        スレッドのコレクション
      • getSharedQueuedThreads

        public final Collection<Thread> getSharedQueuedThreads()
        共有モードで取得するために待機中のスレッドを含むコレクションを返します。 これは、共有的取得のために待機中のスレッドのみを返すことを除いては、getQueuedThreads()と同じプロパティを保持します。
        戻り値:
        スレッドのコレクション
      • toString

        public String toString()
        シンクロナイザおよびその状態を識別する文字列を返します。 状態は括弧で囲まれ、文字列"State ="に続いてgetState()の現在値、およびキューが空かどうかに応じて"nonempty"または"empty"が含まれます。
        オーバーライド:
        toString 、クラス:  Object
        戻り値:
        このシンクロナイザおよびその状態を識別する文字列
      • owns

        public final boolean owns​(AbstractQueuedSynchronizer.ConditionObject condition)
        指定されたConditionObjectがこのシンクロナイザをロックとして使用するかどうかを照会します。
        パラメータ:
        condition - 状態
        戻り値:
        所有される場合はtrue
        例外:
        NullPointerException - 状態がnullの場合
      • hasWaiters

        public final boolean hasWaiters​(AbstractQueuedSynchronizer.ConditionObject condition)
        このシンクロナイザに関連付けられた指定の状態で待機しているスレッドが存在するかどうかを照会します。 タイム・アウトおよび割込みはいつでも発生する可能性があるため、trueが返されても、将来signalがスレッドを起動させることは保証されていません。 このメソッドは、主にシステム状態の監視に使用する目的で設計されています。
        パラメータ:
        condition - 状態
        戻り値:
        待機中のスレッドが存在する場合はtrue
        例外:
        IllegalMonitorStateException - 排他的同期が保持されない場合
        IllegalArgumentException - 指定された状態がこのシンクロナイザと関連付けられていない場合
        NullPointerException - 状態がnullの場合
      • getWaitQueueLength

        public final int getWaitQueueLength​(AbstractQueuedSynchronizer.ConditionObject condition)
        このシンクロナイザに関連付けられた指定の状態で待機しているスレッドの推定数を返します。 タイム・アウトおよび割り込みの発生する可能性はいつでも存在するため、推定数は、実際の待機者数に関する上限を示すに過ぎません。 このメソッドは、同期の制御用としてではなく、システム状態の監視用として設計されています。
        パラメータ:
        condition - 状態
        戻り値:
        待機中のスレッドの推定数
        例外:
        IllegalMonitorStateException - 排他的同期が保持されない場合
        IllegalArgumentException - 指定された状態がこのシンクロナイザと関連付けられていない場合
        NullPointerException - 状態がnullの場合
      • getWaitingThreads

        public final Collection<Thread> getWaitingThreads​(AbstractQueuedSynchronizer.ConditionObject condition)
        このシンクロナイザに関連付けられた指定の状態で待機中のスレッドを含むコレクションを返します。 実際のスレッド・セットは、結果の構築中にも動的に変化する可能性があるため、返されるコレクションは最善の努力を払った上での推定に過ぎません。 返されるコレクションの要素には、特定の順序は存在しません。
        パラメータ:
        condition - 状態
        戻り値:
        スレッドのコレクション
        例外:
        IllegalMonitorStateException - 排他的同期が保持されない場合
        IllegalArgumentException - 指定された状態がこのシンクロナイザと関連付けられていない場合
        NullPointerException - 状態がnullの場合