java.util.concurrent.locks
類別 AbstractQueuedSynchronizer

java.lang.Object
  java.util.concurrent.locks.AbstractOwnableSynchronizer
      java.util.concurrent.locks.AbstractQueuedSynchronizer

所有已實作的介面：

Serializable

public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements Serializable

為實作依賴於先進先出 (FIFO) 等待佇列的阻塞鎖和相關同步器（信號量、事件，等等）提供一個框架。此類別的設計目標是成為依靠單個原子 int 值來表示狀態的大多數同步器的一個有用基礎。子類別必須定義更改此狀態的受保護方法，並定義哪種狀態對於此物件意味著被獲取或被釋放。假定這些條件之後，此類別中的其他方法就可以實作所有排隊和阻塞機制。子類別可以維護其他狀態欄位，但只是為了獲得同步而只追蹤使用 getState()、setState(int) 和 compareAndSetState(int, int) 方法來操作以原子方式更新的 int 值。

應該將子類別定義為非公共內部說明器類別，可用它們來實作其封閉類別的同步屬性。類別 AbstractQueuedSynchronizer 沒有實作任何同步介面。而是定義了諸如 acquireInterruptibly(int) 之類別的一些方法，在適當的時候可以通過具體的鎖和相關同步器來調用它們，以實作其公共方法。

此類別支持預設的獨佔 網要和共享 網要之一，或者二者都支持。處於獨佔網要下時，其他執行緒試圖獲取該鎖將無法取得成功。在共享網要下，多個執行緒獲取某個鎖可能（但不是一定）會獲得成功。此類別並不“瞭解”這些不同，除了機械地意識到當在共享網要下成功獲取某一鎖時，下一個等待執行緒（如果存在）也必須確定自己是否可以成功獲取該鎖。處於不同網要下的等待執行緒可以共享相同的 FIFO 佇列。通常，實作子類別只支持其中一種網要，但兩種網要都可以在（例如）ReadWriteLock 中發揮作用。只支持獨佔網要或者只支持共享網要的子類別不必定義支持未使用網要的方法。

此類別通過支持獨佔網要的子類別定義了一個巢狀的 AbstractQueuedSynchronizer.ConditionObject 類別，可以將這個類別用作 Condition 實作。isHeldExclusively() 方法將報告同步對於當前執行緒是否是獨佔的；使用當前 getState() 值調用 release(int) 方法則可以完全釋放此物件；如果給定保存的狀態值，那麼 acquire(int) 方法可以將此物件最終恢復為它以前獲取的狀態。沒有別的 AbstractQueuedSynchronizer 方法創建這樣的條件，因此，如果無法滿足此約束，則不要使用它。AbstractQueuedSynchronizer.ConditionObject 的行為當然取決於其同步器實作的語義。

此類別為內部佇列提供了檢查、檢測和監視方法，還為 condition 物件提供了類似方法。可以根據需要使用用於其同步機制的 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 來禁用闖入。特別是 getFirstQueuedThread() 沒有返回當前執行緒的時候，嚴格的 FIFO 鎖定可以定義 tryAcquire 立即返回 false。只有 hasQueuedThreads() 返回 true 並且 getFirstQueuedThread 不是當前執行緒時，更好的非嚴格公平的版本才可能會立即返回 false；如果 getFirstQueuedThread 不為 null 並且不是當前執行緒，則產生的結果相同。出現進一步的變體也是有可能的。

對於預設闖入（也稱為 greedy、renouncement 和 convoy-avoidance）策略，吞吐量和可伸縮性通常是最高的。儘管無法保證這是公平的或是無偏向的，但允許更早加入佇列的執行緒先於更遲加入佇列的執行緒再次爭用資源，並且相對於傳入的執行緒，每個參與再爭用的執行緒都有平等的成功機會。此外，儘管從一般意義上說，獲取並非“自旋”，它們可以在阻塞之前對用其他計算所使用的 tryAcquire 執行多次調用。在只保持獨佔同步時，這為自旋提供了最大的好處，但不是這種情況時，也不會帶來最大的負擔。如果需要這樣做，那麼可以使用“快速路徑”檢查來先行調用 acquire 方法，以這種方式擴充這一點，如果可能不需要爭用同步器，則只能通過預先檢查 hasContended() 和/或 hasQueuedThreads() 來確認這一點。

通過特殊化其同步器的使用範圍，此類別為部分同步化提供了一個有效且可伸縮的基礎，同步器可以依賴於 int 型的 state、acquire 和 release 參數，以及一個內部的 FIFO 等待佇列。這些還不夠的時候，可以使用 atomic 類別、自己的定制 Queue 類別和 LockSupport 阻塞支持，從更低層級別建構同步器。

使用範例

以下是一個非再進入的互斥鎖類別，它使用值 0 表示未鎖定狀態，使用 1 表示鎖定狀態。當非重入鎖定不嚴格地需要當前擁有者執行緒的記錄時，此類別使得使用監視器更加方便。它還支持一些條件並公開了一個檢測方法：

 class Mutex implements Lock, java.io.Serializable {

    // Our internal helper class
    private static class Sync extends AbstractQueuedSynchronizer {
      // Report whether in locked state
      protected boolean isHeldExclusively() { 
        return getState() == 1; 
      }

      // Acquire 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;
      }

      // Release the lock by setting state to zero
      protected boolean tryRelease(int releases) {
        assert releases == 1; // Otherwise unused
        if (getState() == 0) throw new IllegalMonitorStateException();
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
      }
       
      // Provide a Condition
      Condition newCondition() { return new ConditionObject(); }

      // Deserialize 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.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);
    }
 }

 

從以下版本開始：

1.5

另請參見：

序列化表格

巢狀類別摘要

class

AbstractQueuedSynchronizer.ConditionObject AbstractQueuedSynchronizer 的 Condition 實作是 Lock 實作的基礎。

建構子摘要

protected

AbstractQueuedSynchronizer() 創建具有初始同步狀態 0 的新 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() 返回包含可能正以獨佔網要等待獲取的執行緒 collection。
Thread	getFirstQueuedThread() 返回佇列中第一個（等待時間最長的）執行緒，如果目前沒有將任何執行緒加入佇列，則返回 null. 在此實作中，該操作是以固定時間返回的，但是，如果其他執行緒目前正在共時修改該佇列，則可能出現循環爭用。
Collection<Thread>	getQueuedThreads() 返回包含可能正在等待獲取的執行緒 collection。
int	getQueueLength() 返回等待獲取的執行緒數估計值。
Collection<Thread>	getSharedQueuedThreads() 返回包含可能正以共享網要等待獲取的執行緒 collection。
protected int	getState() 返回同步狀態的當前值。
Collection<Thread>	getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition) 返回一個 collection，其中包含可能正在等待與此同步器有關的給定條件的那些執行緒。
int	getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition) 返回正在等待與此同步器有關的給定條件的執行緒數估計值。
boolean	hasContended() 查詢是否其他執行緒也曾爭著獲取此同步器；也就是說，是否某個 acquire 方法已經阻塞。
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) 試圖設置狀態來反映共享網要下的一個釋放。

從類別 java.util.concurrent.locks.AbstractOwnableSynchronizer 繼承的方法

getExclusiveOwnerThread, setExclusiveOwnerThread

從類別 java.lang.Object 繼承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

建構子詳細資訊

AbstractQueuedSynchronizer

protected AbstractQueuedSynchronizer()

創建具有初始同步狀態 0 的新 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)

試圖在獨佔網要下獲取物件狀態。此方法應該查詢是否允許它在獨佔網要下獲取物件狀態，如果允許，則獲取它。

此方法總是由執行 acquire 的執行緒來調用。如果此方法報告失敗，則 acquire 方法可以將執行緒加入佇列（如果還沒有將它加入佇列），直到獲得其他某個執行緒釋放了該執行緒的信號。可以用此方法來實作 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)

試圖在共享網要下獲取物件狀態。此方法應該查詢是否允許它在共享網要下獲取物件狀態，如果允許，則獲取它。

此方法總是由執行 acquire 執行緒來調用。如果此方法報告失敗，則 acquire 方法可以將執行緒加入佇列（如果還沒有將它加入佇列），直到獲得其他某個執行緒釋放了該執行緒的信號。

預設實作將拋出 UnsupportedOperationException。

參數：

arg - acquire 參數。該值總是傳遞給 acquire 方法的那個值，或者是因某個條件等待而保存在條目上的值。該值是不間斷的，並且可以表示任何內容。

返回：

在失敗時返回負值；如果共享網要下的獲取成功但其後續共享網要下的獲取不能成功，則返回 0；如果共享網要下的獲取成功並且其後續共享網要下的獲取可能夠成功，則返回正值，在這種情況下，後續等待執行緒必須檢查可用性。（對三種返回值的支持使得此方法可以在只是有時候以獨佔方式獲取物件的上下文中使用。）在成功的時候，此物件已被獲取。

拋出：

IllegalMonitorStateException - 如果正在進行的獲取操作將在非法狀態下放置此同步器。必須以一致的方式拋出此異常，以便同步正確運行。

UnsupportedOperationException - 如果不支持共享網要

tryReleaseShared

protected boolean tryReleaseShared(int arg)

試圖設置狀態來反映共享網要下的一個釋放。

此方法總是由正在執行釋放的執行緒調用。

預設實作將拋出 UnsupportedOperationException。

參數：

arg - release 參數。該值總是傳遞給 release 方法的那個值，或者是因某個條件等待而保存在條目上的當前狀態值。該值是不間斷的，並且可以表示任何內容。

返回：

如果此物件現在處於完全釋放狀態，從而使正在等待的執行緒都可以試圖獲得此物件，則返回 true；否則返回 false

拋出：

IllegalMonitorStateException - 如果正在進行的釋放操作將在非法狀態下放置此同步器。必須以一致的方式拋出此異常，以便同步正確運行

UnsupportedOperationException - 如果不支持共享網要

isHeldExclusively

protected boolean isHeldExclusively()

如果對於當前（正調用的）執行緒，同步是以獨佔方式進行的，則返回 true。此方法是在每次調用非等待 AbstractQueuedSynchronizer.ConditionObject 方法時調用的。（等待方法則調用 release(int)。）

預設實作將拋出 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，則通過消除一個或多個執行緒的阻塞來實作此方法。可以使用此方法來實作 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，則通過消除一個或多個執行緒的阻塞來實作該方法。

參數：

arg - release 參數。此值被傳送給 tryReleaseShared(int)，但它是不間斷的，並且可以表示任何內容。

返回：

從 tryReleaseShared(int) 中返回的值

hasQueuedThreads

public final boolean hasQueuedThreads()

查詢是否有正在等待獲取的任何執行緒。注意，隨時可能因為中斷和逾時而導致取消操作，返回 true 並不能保證其他任何執行緒都將獲取物件。

在此實作中，該操作是以固定時間返回的。

返回：

如果可能有其他執行緒正在等待獲取鎖，則返回 true。

hasContended

public final boolean hasContended()

查詢是否其他執行緒也曾爭著獲取此同步器；也就是說，是否某個 acquire 方法已經阻塞。

在此實作中，該操作是以固定時間返回的。

返回：

如果曾經出現爭用，則返回 true

getFirstQueuedThread

public final Thread getFirstQueuedThread()

返回佇列中第一個（等待時間最長的）執行緒，如果目前沒有將任何執行緒加入佇列，則返回 null.

在此實作中，該操作是以固定時間返回的，但是，如果其他執行緒目前正在共時修改該佇列，則可能出現循環爭用。

返回：

佇列中第一個（等待時間最長的）執行緒，如果目前沒有將任何執行緒加入佇列，則返回 null

isQueued

public final boolean isQueued(Thread thread)

如果給定執行緒的當前已加入佇列，則返回 true。

該實作將遍歷佇列，以確定給定執行緒是否存在。

參數：

thread - 執行緒

返回：

如果給定執行緒在佇列中，則返回 true

拋出：

NullPointerException - 如果 thread 為 null

getQueueLength

public final int getQueueLength()

返回等待獲取的執行緒數估計值。該值只能是一個估計值，因為在此方法遍歷內部資料結構時，執行緒的數量可能發生大的變化。該方法是為用來監視系統狀態而設計的，不是為同步控制設計的。

返回：

正等待獲取的執行緒估計數

getQueuedThreads

public final Collection<Thread> getQueuedThreads()

返回包含可能正在等待獲取的執行緒 collection。因為在建構該結果時，實際執行緒 set 可能發生大的變化，所以返回的 collection 只是盡最大努力獲得的一個估計值。返回 collection 的元素並不是以特定順序排列的。此方法是為促進子類別的建構而設計的，這些子類別提供了大量的監視設施。

返回：

執行緒的 collection

getExclusiveQueuedThreads

public final Collection<Thread> getExclusiveQueuedThreads()

返回包含可能正以獨佔網要等待獲取的執行緒 collection。此方法具有與 getQueuedThreads() 相同的屬性，除了它只返回那些因獨佔獲取而等待的執行緒。

返回：

執行緒的 collection

getSharedQueuedThreads

public final Collection<Thread> getSharedQueuedThreads()

返回包含可能正以共享網要等待獲取的執行緒 collection。此方法具有與 getQueuedThreads() 相同的屬性，除了它只返回那些因共享獲取而等待的執行緒。

返回：

執行緒的 collection

toString

public String toString()

返回標識此同步器及其狀態的字元串。此狀態被括號括起來，它包括字元串 "State ="，後面是 getState() 的當前值，再後面是 "nonempty" 或 "empty"，這取決於佇列是否為空。

覆寫：

類別 Object 中的 toString

返回：

標識此同步器及其狀態的字元串

owns

public final boolean owns(AbstractQueuedSynchronizer.ConditionObject condition)

查詢給定的 ConditionObject 是否使用了此同步器作為其鎖。

參數：

condition - 條件

返回：

如果具備此條件，則返回 true

拋出：

NullPointerException - 如果 condition 為 null

hasWaiters

public final boolean hasWaiters(AbstractQueuedSynchronizer.ConditionObject condition)

查詢是否有執行緒正在等待給定的、與此同步器相關的條件。注意，因為隨時可能發生逾時和中斷，所以返回 true 並不能保證將來某個 signal 將喚醒任何執行緒。此方法主要是為了監視系統狀態而設計的。

參數：

condition - 條件

返回：

如果有正在等待的執行緒，則返回 true

拋出：

IllegalMonitorStateException - 如果不進行獨佔同步

IllegalArgumentException - 如果給定的 condition 與此同步器無關

NullPointerException - 如果 condition 為 null

getWaitQueueLength

public final int getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition)

返回正在等待與此同步器有關的給定條件的執行緒數估計值。注意，因為隨時可能發生逾時和中斷，所以估計值只是實際等待執行緒的數量上限。此方法是為監視系統狀態而設計的，不是為同步控制設計的。

參數：

condition - 條件

返回：

等待執行緒的估計數

拋出：

IllegalMonitorStateException - 如果不進行獨佔同步

IllegalArgumentException - 如果給定的 condition 與此同步器無關

NullPointerException - 如果 condition 為 null

getWaitingThreads

public final Collection<Thread> getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)

返回一個 collection，其中包含可能正在等待與此同步器有關的給定條件的那些執行緒。因為在建構該結果時，實際執行緒 set 可能發生大的變化，所以返回的 collection 只是盡最大努力獲得的一個估計值。返回 collection 的元素並不是以特定順序排列的。

參數：

condition - 條件

返回：

執行緒的 collection

拋出：

IllegalMonitorStateException - 如果不進行獨佔同步

IllegalArgumentException - 如果給定的 condition 與此同步器無關

NullPointerException - 如果 condition 為 null