AbstractQueuedSynchronizer クラス

定義

名前空間:: Java.Util.Concurrent.Locks

アセンブリ:: Mono.Android.dll

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。

[Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)]
public abstract class AbstractQueuedSynchronizer : Java.Util.Concurrent.Locks.AbstractOwnableSynchronizer, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)>]
type AbstractQueuedSynchronizer = class
    inherit AbstractOwnableSynchronizer
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

継承: Object

Object

AbstractOwnableSynchronizer
AbstractQueuedSynchronizer

属性: RegisterAttribute

実装: IJavaObject IJavaPeerable ISerializable IDisposable

注釈

先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。このクラスは、状態を表すために単一のアトミックな int 値に依存するほとんどの種類のシンクロナイザーにとって有用な基礎として設計されています。サブクラスは、この状態を変更する保護されたメソッドを定義し、このオブジェクトが取得または解放されるという点でその状態が何を意味するかを定義する必要があります。これらを考えると、このクラスの他のメソッドは、すべてのキューとブロックのメカニズムを実行します。サブクラスは他の状態フィールドを維持できますが、同期に関して追跡されるのは、#getState、#setState、#compareAndSetStateのメソッドを使用して操作されたアトミックに更新されたint値だけです。

サブクラスは、外側のクラスの同期プロパティを実装するために使用される、パブリックでない内部ヘルパークラスとして定義する必要があります。クラス AbstractQueuedSynchronizer では、同期インターフェイスは実装されません。代わりに、パブリックメソッドを実装するために、具象ロックおよび関連するシンクロナイザーによって必要に応じて呼び出すことができる #acquireInterruptibly などのメソッドを定義します。

このクラスは、既定の <em>exclusive</em> モードと <em>shared</em> モードのいずれかまたは両方をサポートします。排他モードで取得した場合、他のスレッドによる取得の試行は成功できません。複数のスレッドによって取得される共有モードは成功する可能性があります (ただし、必要ありません)。このクラスは quot を実行しません。理解>これらの違いは、共有モードが正常に取得されると、次の待機スレッド (存在する場合) も取得できるかどうかを判断する必要があるという機械的な意味を除きます。異なるモードで待機しているスレッドは、同じ FIFO キューを共有します。通常、実装サブクラスはこれらのモードの 1 つだけをサポートしますが、どちらもたとえば、 ReadWriteLockで使用できます。排他モードまたは共有モードのみをサポートするサブクラスでは、未使用モードをサポートするメソッドを定義する必要はありません。

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

このクラスは、内部キューの検査、インストルメンテーション、および監視のメソッドと、条件オブジェクトの同様のメソッドを提供します。これらは、同期メカニズムの AbstractQueuedSynchronizer を使用して、必要に応じてクラスにエクスポートできます。

このクラスのシリアル化では、基になるアトミック整数の保持状態のみが格納されるため、逆シリアル化されたオブジェクトには空のスレッドキューがあります。シリアル化可能性を必要とする一般的なサブクラスは、逆シリアル化時にこれを既知の初期状態に復元する readObject メソッドを定義します。

<h2>Usage</h2>

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

<ul><li>#tryAcquire<li>#tryRelease<li>#tryAcquireShared<li>#tryReleaseShared<li>#isHeldExclusively</ul>

既定では、これらの各メソッドは UnsupportedOperationExceptionをスローします。これらのメソッドの実装は、内部的にスレッドセーフである必要があり、一般的には短く、ブロックしないようにする必要があります。これらのメソッドの定義は、 <em>only</em> サポートされるこのクラスの使用方法です。他のすべてのメソッドは個別に変更できないため、 final 宣言されます。

また、 AbstractOwnableSynchronizer から継承されたメソッドは、排他シンクロナイザーを所有するスレッドを追跡するのに役立つ場合もあります。これらを使用することをお勧めします。これにより、監視ツールと診断ツールを使用して、ユーザーがロックを保持しているスレッドを判断するのに役立ちます。

このクラスは内部 FIFO キューに基づいていますが、FIFO 取得ポリシーは自動的に適用されません。排他同期のコアは、次の形式になります。

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

<em>Release:</em>
                if (tryRelease(arg))
<em>unblock the first queued thread</em>;

(共有モードは似ていますが、カスケード信号を伴う場合があります)。

エンキューする前にチェックインが呼び出されるため、新しく取得するスレッドは、ブロックされてキューに登録されている他のスレッドよりも <em>barge</em> 可能性があります。ただし、必要に応じて、1 つ以上の検査方法を内部的に呼び出して tryAcquire や tryAcquireShared を定義してバージを無効にし、FIFO 取得順序を <em>fair</em> 指定できます。特に、ほとんどのフェアシンクロナイザーは、#hasQueuedPredecessors (特にフェアシンクロナイザーによって使用されるように設計されたメソッド) がtrueを返す場合に、falseを返すtryAcquireを定義できます。その他のバリエーションも可能です。

スループットとスケーラビリティは、一般に、既定のバージ ( <em>greedy</em>、 <em>renouncement</em>、および <em>convoy-avoidance</em>) 戦略で最も高くなります。これは公平または不足が発生しないことは保証されませんが、キューに登録された以前のスレッドは、後でキューに登録されたスレッドの前に再コンテンドすることが許可され、各再調整には受信スレッドに対して成功する機会が偏っていません。また、取得は量子ではありません。spin>通常の意味では、ブロックする前に、他の計算に散在する tryAcquire の複数の呼び出しを実行できます。これにより、排他的同期が短時間しか保持されていない場合、スピンの利点の大部分が得られます。そうでない場合は、ほとんどの負債が発生しません。必要に応じて、前述の呼び出しで"高速パス" チェックを使用してメソッドを取得し、 #hasContended や #hasQueuedThreads を事前チェックして、シンクロナイザーが意図されていない可能性がある場合にのみこれを行うことができます。

このクラスは、 int 状態、取得、解放パラメーター、および内部 FIFO 待機キューに依存できるシンクロナイザーに、その使用範囲を特殊化することで、同期の一部として効率的でスケーラブルな基礎を提供します。これで十分でない場合は、 java.util.concurrent.atomic atomic クラス、独自のカスタム java.util.Queue クラス、およびブロックサポートを使用して、下位レベルからシンクロナイザー LockSupport 構築できます。

ロック解除された状態を表すために値 0 を使用し、1 つを使用してロック状態を表す非再入可能な相互除外ロッククラスを次に示します。再入不可能なロックでは、現在の所有者スレッドの記録は厳密には必要ありませんが、このクラスは、使用状況を監視しやすくするために必要です。また、条件をサポートし、いくつかのインストルメンテーションメソッドを公開します。

{@code
            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));
              }
            }}

java.util.concurrent.CountDownLatch CountDownLatchのようなラッチクラスを次に示します。ただし、1 つのsignalを起動するだけで済みます。ラッチは非排他的であるため、 shared の取得および解放メソッドを使用します。

{@code
            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 で追加されました。

Javaドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

コンストラクター

名前	説明
AbstractQueuedSynchronizer()	初期同期状態が 0 の新しい `AbstractQueuedSynchronizer` インスタンスを作成します。
AbstractQueuedSynchronizer(IntPtr, JniHandleOwnership)	JNI オブジェクトのマネージド表現を作成するときに使用されるコンストラクター。ランタイムによって呼び出されます。

プロパティ

名前	説明
Class	この `Object`のランタイムクラスを返します。 (継承元 Object)
ExclusiveOwnerThread	`setExclusiveOwnerThread`によって最後に設定されたスレッドを返します。設定しない場合は`null`します。または、現在排他アクセスを所有しているスレッドを設定します。 (継承元 AbstractOwnableSynchronizer)
ExclusiveQueuedThreads	排他モードでの取得を待機している可能性があるスレッドを含むコレクションを返します。
FirstQueuedThread	キュー内の最初の (待機時間が最も長い) スレッドを返します。現在キューに入っているスレッドがない場合は `null` します。
Handle	基になる Android インスタンスへのハンドル。 (継承元 Object)
HasContended	スレッドがこのシンクロナイザーの取得を意図したかどうかをクエリします。つまり、取得メソッドがブロックされた場合です。
HasQueuedPredecessors	現在のスレッドよりも長い取得を待機しているスレッドがあるかどうかをクエリします。
HasQueuedThreads	取得を待機しているスレッドがあるかどうかをクエリします。
IsHeldExclusively	現在の (呼び出し元) スレッドに対して同期が排他的に保持されている場合は、 `true` を返します。
JniIdentityHashCode	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
JniPeerMembers	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。
PeerReference	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
QueuedThreads	取得を待機している可能性があるスレッドを含むコレクションを返します。
QueueLength	取得を待機しているスレッドの数の推定値を返します。
SharedQueuedThreads	共有モードでの取得を待機している可能性があるスレッドを含むコレクションを返します。
State	同期状態の現在の値を返します。または、同期状態の値を設定します。
ThresholdClass	この API は Android 用 Mono インフラストラクチャをサポートしており、コードから直接使用するためのものではありません。
ThresholdType	この API は Android 用 Mono インフラストラクチャをサポートしており、コードから直接使用するためのものではありません。

メソッド

名前	説明
Acquire(Int32)	割り込みを無視して排他モードで取得します。
AcquireInterruptibly(Int32)	排他モードで取得し、中断された場合は中止します。
AcquireShared(Int32)	割り込みを無視して共有モードで取得します。
AcquireSharedInterruptibly(Int32)	共有モードで取得し、中断された場合は中止します。
Clone()	このオブジェクトのコピーを作成して返します。 (継承元 Object)
CompareAndSetState(Int32, Int32)	現在の状態の値が期待値と等しい場合、同期状態を指定された更新された値にアトミックに設定します。
Dispose()	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
Dispose(Boolean)	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
Equals(Object)	他のオブジェクトがこのオブジェクトと "等しい" かどうかを示します。 (継承元 Object)
GetHashCode()	オブジェクトのハッシュコード値を返します。 (継承元 Object)
GetWaitingThreads(AbstractQueuedSynchronizer+ConditionObject)	このシンクロナイザーに関連付けられている特定の条件で待機している可能性があるスレッドを含むコレクションを返します。
GetWaitQueueLength(AbstractQueuedSynchronizer+ConditionObject)	このシンクロナイザーに関連付けられている特定の条件で待機しているスレッドの数の推定値を返します。
HasWaiters(AbstractQueuedSynchronizer+ConditionObject)	このシンクロナイザーに関連付けられている特定の条件でスレッドが待機しているかどうかをクエリします。
IsQueued(Thread)	指定されたスレッドが現在キューに入っている場合は true を返します。
JavaFinalize()	オブジェクトへの参照がなくなったとガベージコレクションによって判断されたときに、オブジェクトのガベージコレクターによって呼び出されます。 (継承元 Object)
Notify()	このオブジェクトのモニターで待機している 1 つのスレッドを起動します。 (継承元 Object)
NotifyAll()	このオブジェクトのモニターで待機しているすべてのスレッドを起動します。 (継承元 Object)
Owns(AbstractQueuedSynchronizer+ConditionObject)	指定された ConditionObject がこのシンクロナイザーをロックとして使用するかどうかをクエリします。
Release(Int32)	排他モードでのリリース。
ReleaseShared(Int32)	共有モードでのリリース。
SetHandle(IntPtr, JniHandleOwnership)	Handle プロパティを設定します。 (継承元 Object)
ToArray<T>()	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
ToString()	オブジェクトの文字列形式を返します。 (継承元 Object)
TryAcquire(Int32)	排他モードで取得を試みます。
TryAcquireNanos(Int32, Int64)	排他モードで取得を試み、中断された場合は中止し、指定されたタイムアウトが経過すると失敗します。
TryAcquireShared(Int32)	共有モードで取得を試みます。
TryAcquireSharedNanos(Int32, Int64)	共有モードで取得を試み、中断された場合は中止し、指定されたタイムアウトが経過すると失敗します。
TryRelease(Int32)	排他モードでリリースを反映するように状態を設定しようとします。
TryReleaseShared(Int32)	共有モードでのリリースを反映するように状態の設定を試みます。
UnregisterFromRuntime()	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
Wait()	現在のスレッドが起動するまで待機します。通常は、 <em>notified</em> または <em>interrupted</em>。 (継承元 Object)
Wait(Int64, Int32)	現在のスレッドは、通常、 <em>notified</em> または <em>interrupted</em>、または一定のリアルタイムが経過するまで、起動されるまで待機します。 (継承元 Object)
Wait(Int64)	現在のスレッドは、通常、 <em>notified</em> または <em>interrupted</em>、または一定のリアルタイムが経過するまで、起動されるまで待機します。 (継承元 Object)

明示的なインターフェイスの実装

名前	説明
IJavaPeerable.Disposed()	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
IJavaPeerable.DisposeUnlessReferenced()	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
IJavaPeerable.Finalized()	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
IJavaPeerable.JniManagedPeerState	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。 (継承元 Object)

拡張メソッド

名前	説明
GetJniTypeName(IJavaPeerable)	インスタンス `self`の型の JNI 名を取得します。
JavaAs<TResult>(IJavaPeerable)	`self`を強制的に`TResult`入力し、強制型がJava側で有効であることを確認します。
JavaCast<TResult>(IJavaObject)	Android ランタイムチェック型変換を実行します。
JavaCast<TResult>(IJavaObject)	先入れ先出し (FIFO) 待機キューに依存するブロックロックと関連するシンクロナイザー (セマフォ、イベントなど) を実装するためのフレームワークを提供します。
TryJavaCast<TResult>(IJavaPeerable, TResult)	`self`を強制的に`TResult`入力し、強制型がJava側で有効であることを確認します。

適用対象