AbstractQueuedSynchronizer

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

基本介紹

• 中文名：AbstractQueuedSynchronizer
• 外文名：AbstractQueuedSynchronizer
• 作用：信號量、事件
• 又名：java.lang.Object

概述

類 AbstractQueuedSynchronizer

java.lang.Object

java.util.concurrent.locks.AbstractQueuedSynchronizer

所有已實現的接口：

.Serializable

簡介

應該將子類定義為非公共內部幫助器類，可用它們來實現其封閉類的同步屬性。

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，因為它們無法是各不相同的。

即使此類基於內部的某個 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,.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

return compareAndSetState(0,1）；

}

// Release the lock by setting state to zero

protected boolean tryRelease(int releases) {

assert releases == 1; // Otherwise unused

if (getState() == 0) throw new IllegalMonitorStateException();

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⑴； }

public boolean tryLock() { return sync.tryAcquire⑴； }

public void unlock() { sync.release⑴； }

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⑴；

}

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⑴；

return true;

}

}

private final Sync sync = new Sync();

public boolean isSignalled() { return sync.isSignalled(); }

public void signal() { sync.releaseShared⑴； }

public void await() throws InterruptedException {

sync.acquireSharedInterruptibly⑴；

}

}

從以下版本開始：

⒈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.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

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