AbstractQueuedSynchronizer 類別

定義

命名空間:

Java.Util.Concurrent.Locks

組件:

Mono.Android.dll

提供架構，以實作封鎖鎖定和相關同步器， (旗號、事件等) 依賴先出 (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操作的不可部分完成更新int值，#setState而且#compareAndSetState會追蹤同步處理。

子類別應該定義為非公用的內部協助程式類別，這些類別是用來實作其封入類別的同步處理屬性。 類別 AbstractQueuedSynchronizer 不會實作任何同步處理介面。 相反地，它會定義方法，例如 #acquireInterruptibly 可由具體鎖定和相關同步器適當叫用的方法，以實作其公用方法。

這個類別支援或同時支援預設 <em> 獨佔</em> 模式和 <em>共用</em> 模式。 在獨佔模式中取得時，其他線程嘗試取得無法成功。 多個線程取得的共用模式可能會 (，但不需要) 成功。 這個類別不會 &商;瞭解&商;除了機械性上的差異以外，當共用模式取得成功時，下一個等候線程 (如果有的話，) 也必須判斷是否可以取得。 在不同模式中等候的線程會共用相同的 FIFO 佇列。 實作子類別通常只支援下列其中一種模式，但兩者都可以在 中 ReadWriteLock運作，例如。 僅支持獨佔或僅共用模式的子類別不需要定義支援未使用模式的方法。

這個類別會定義巢狀ConditionObject類別，這個類別可由支持獨佔模式的子類別用來實Condition作，此方法#isHeldExclusively會報告同步處理是否與目前線程有關、使用目前#getState值叫用的方法#release會完整釋放這個物件，而且#acquire如果這個已儲存的狀態值，最終會將這個物件還原到其先前取得的狀態。 沒有 AbstractQueuedSynchronizer 方法否則會建立這類條件，因此如果無法符合此條件約束，請勿使用它。 的行為 ConditionObject 當然取決於其同步器實作的語意。

這個類別提供內部佇列的檢查、檢測和監視方法，以及條件對象的類似方法。 您可以視需要將這些屬性匯出到類別中，以用於 AbstractQueuedSynchronizer 其同步處理機制。

這個類別的串行化只會儲存基礎不可部分完成的整數維護狀態，因此還原串行化的物件會有空的線程佇列。 需要串行化的一般子類別會定義 readObject 方法，以在還原串行化時將此還原為已知的初始狀態。

<h2>使用量</h2>

若要使用這個類別做為同步器的基礎，請使用 和/或 檢查和/或#compareAndSetState修改同步處理狀態#getState#setState，以視情況重新定義下列方法：

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

每個方法預設都會擲回 UnsupportedOperationException。 這些方法的實作必須是內部安全線程，而且通常應該簡短且不會封鎖。 定義這些方法是<使用這個類別的唯<一>/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>;

(共用模式很類似，但可能牽涉到串聯訊號。)

<p id=“barging”>由於在加入佇列之前會叫用取得中的檢查，所以新取得的線程可能會在 <封鎖和排入佇列的其他線程之前先叫>用 barge</em> 。 不過，如有需要，您可以透過內部叫用一或多個檢查方法來定義tryAcquire和/或tryAcquireShared停用列，藉此提供<公平></em> FIFO 取得訂單。 特別是，如果 #hasQueuedPredecessors (專為公平同步器所設計的方法，) 傳true回 ，則大部分公平同步器都可以定義tryAcquire傳回 false 。 可能會有其他變化。

輸送量和延展性通常最高，適用於<預設列 (也稱為 emgredy<>/em>、<em renouancement</em> 和 <em>>convoy-avoidance</em>) 策略。 雖然這不保證是公平或無用的，但較早的佇列線程可以在稍後的佇列線程之前進行偵察，而且每個偵察都有機會對傳入的線程成功。 此外，雖然取得不會 &商數;微調&商;在一般情況下，它們可能會在封鎖之前，先執行多個與其他計算交錯的 tryAcquire 調用。 這可在只有短暫保留獨佔同步處理時提供微調的大部分優點，而不會在不需要時承擔大部分的責任。 如有需要，您可以藉由先前呼叫取得具有「快速路徑」檢查的方法來擴增這項功能，可能只有在同步器可能沒有競爭時，才進行預先檢查 #hasContended 和/或 #hasQueuedThreads 。

這個類別提供一部分有效率且可調整的同步處理基礎，方法是將其使用範圍特製化給可依賴 int 狀態、取得和釋放參數的同步器，以及內部 FIFO 等候佇列。 當這不足夠時，您可以使用類別、您自己的自定義java.util.Queue類別和LockSupport封鎖支援，從較低層級java.util.concurrent.atomic atomic建置同步器。

<h2>使用範例</h2>

以下是非重新進入互斥鎖定類別，使用零值來表示解除鎖定狀態，另一個表示鎖定狀態。 雖然非重新進入鎖定不需要記錄目前的擁有者線程，但這個類別仍會這麼做，以便更輕鬆地監視使用方式。 它也支援條件並公開一些檢測方法：

{@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 的閂鎖類別，不同之處在於它只需要引發單 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.util.concurrent.locks.AbstractQueuedSynchronizerJava 檔。

此頁面的部分是根據 原始碼專案所建立和共用的工作進行修改，並根據 中所述的詞彙使用。

建構函式

AbstractQueuedSynchronizer()	建立初始同步處理狀態為零的新 AbstractQueuedSynchronizer 實例。
AbstractQueuedSynchronizer(IntPtr, JniHandleOwnership)	建立 JNI 物件的 Managed 表示法時所使用的建構函式;由運行時間呼叫。

屬性

Class	傳回這個 Object的運行時間類別。 (繼承來源 Object)
ExclusiveOwnerThread	傳回 最後一 setExclusiveOwnerThread次設定的線程，如果從未設定，則 null 傳回 。 -或- 設定目前擁有獨佔存取權的線程。 (繼承來源 AbstractOwnableSynchronizer)
ExclusiveQueuedThreads	傳回集合，其中包含可能等候以獨佔模式取得的線程。
FirstQueuedThread	傳回佇列中第一個 (最長等候) 線程，如果沒有 null 線程目前排入佇列，則傳回 。
Handle	基礎Android實例的句柄。 (繼承來源 Object)
HasContended	查詢是否有任何線程嘗試取得此同步器;也就是說，如果已封鎖 acquire 方法。
HasQueuedPredecessors	查詢是否有任何線程正在等候取得超過目前線程的時間。
HasQueuedThreads	查詢是否有任何線程正在等候取得。
IsHeldExclusively	true如果同步處理與目前呼叫) 線程的目前 (獨佔保留，則傳回 。
JniIdentityHashCode	提供架構，以實作封鎖鎖定和相關同步器， (旗號、事件等) 依賴先出 (FIFO) 等候佇列。 (繼承來源 Object)
JniPeerMembers	提供架構，以實作封鎖鎖定和相關同步器， (旗號、事件等) 依賴先出 (FIFO) 等候佇列。
PeerReference	提供架構，以實作封鎖鎖定和相關同步器， (旗號、事件等) 依賴先出 (FIFO) 等候佇列。 (繼承來源 Object)
QueuedThreads	傳回集合，其中包含可能等候取得的線程。
QueueLength	傳回等候取得的線程數目估計值。
SharedQueuedThreads	傳回集合，其中包含可能等候在共用模式中取得的線程。
State	傳回同步處理狀態的目前值。 -或- 設定同步處理狀態的值。
ThresholdClass	此 API 支援 Mono for Android 基礎結構，並不適合直接從您的程式代碼使用。
ThresholdType	此 API 支援 Mono for Android 基礎結構，並不適合直接從您的程式代碼使用。

方法

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()	喚醒正在等候此物件的監視器的單一線程。 (繼承來源 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)	讓目前的線程等到喚醒為止，通常是<透過em>notified</em或em>interrupted</em>>，或<直到經過一定數量的實時為止。 (繼承來源 Object)
Wait(Int64, Int32)	讓目前的線程等到喚醒為止，通常是<透過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)

擴充方法

JavaCast<TResult>(IJavaObject)	執行 Android 執行時間檢查的類型轉換。
JavaCast<TResult>(IJavaObject)	提供架構，以實作封鎖鎖定和相關同步器， (旗號、事件等) 依賴先出 (FIFO) 等候佇列。
GetJniTypeName(IJavaPeerable)	提供架構，以實作封鎖鎖定和相關同步器， (旗號、事件等) 依賴先出 (FIFO) 等候佇列。