java.util.concurrent.locks
類別 AbstractQueuedLongSynchronizer

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

所有已實作的介面：

Serializable

public abstract class AbstractQueuedLongSynchronizer
extends AbstractOwnableSynchronizer
implements Serializable

以 long 形式維護同步狀態的一個 AbstractQueuedSynchronizer 版本。此類別具有的結構、屬性和方法與 AbstractQueuedSynchronizer 完全相同，但所有與狀態相關的參數和結果都定義為 long 而不是 int。當創建需要 64 位狀態的多級別鎖和屏障等同步器時，此類別很有用。

有關用法說明和範例，請參閱 AbstractQueuedSynchronizer。

從以下版本開始：

1.6

另請參見：

序列化表格

巢狀類別摘要

class

AbstractQueuedLongSynchronizer.ConditionObject 作為 Lock 實作基礎的 AbstractQueuedLongSynchronizer 的條件實作。

建構子摘要

protected

AbstractQueuedLongSynchronizer() 創建一個初始同步狀態為 0 的新 AbstractQueuedLongSynchronizer 實例。

方法摘要

void	acquire(long arg) 以獨佔網要獲取，忽略中斷。
void	acquireInterruptibly(long arg) 以獨佔網要獲取，如果被中斷則中止。
void	acquireShared(long arg) 以共享網要獲取，忽略中斷。
void	acquireSharedInterruptibly(long arg) 以共享網要獲取，如果被中斷則中止。
protected boolean	compareAndSetState(long expect, long update) 如果當前狀態值等於預期值，則以原子方式將同步狀態設置為給定的更新值。
Collection<Thread>	getExclusiveQueuedThreads() 返回一個 collection，該 collection 套件含正以獨佔網要等待獲取的執行緒。
Thread	getFirstQueuedThread() 返回佇列中第一個（等待時間最長的）執行緒；如果當前沒有將任何執行緒加入佇列，則返回 null。
Collection<Thread>	getQueuedThreads() 返回一個 collection，該 collection 套件含正在等待獲取的執行緒。
int	getQueueLength() 返回等待獲取的執行緒估計數。
Collection<Thread>	getSharedQueuedThreads() 返回一個 collection，該 collection 套件含正以共享網要等待獲取的執行緒。
protected long	getState() 返回同步狀態的當前值。
Collection<Thread>	getWaitingThreads(AbstractQueuedLongSynchronizer.ConditionObject condition) 返回一個 collection，該 collection 套件含那些正在與此同步器關聯的給定條件上等待的執行緒。
int	getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition) 返回正在與此同步器關聯的給定條件上等待的執行緒估計數。
boolean	hasContended() 查詢是否有執行緒曾經為獲取此同步器而發生爭用；也就是說，是否某個 acquire 方法曾被阻塞。
boolean	hasQueuedThreads() 查詢是否有等待獲取的執行緒。
boolean	hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition) 查詢是否有執行緒正在與此同步器關聯的給定條件上等待。
protected boolean	isHeldExclusively() 如果對於當前（調用的）執行緒，同步是以獨佔方式進行的，則返回 true。
boolean	isQueued(Thread thread) 如果給定執行緒當前已加入佇列，則返回 true。
boolean	owns(AbstractQueuedLongSynchronizer.ConditionObject condition) 查詢給定 ConditionObject 是否使用此同步器作為它的鎖。
boolean	release(long arg) 以獨佔網要釋放。
boolean	releaseShared(long arg) 以共享網要釋放。
protected void	setState(long newState) 設置同步狀態的值。
String	toString() 返回標識此同步器及其狀態的字元串。
protected boolean	tryAcquire(long arg) 嘗試在獨佔網要下獲取。
boolean	tryAcquireNanos(long arg, long nanosTimeout) 嘗試以獨佔網要獲取，如果被中斷則中止，如果超過給定逾時期則失敗。
protected long	tryAcquireShared(long arg) 嘗試在共享網要下獲取。
boolean	tryAcquireSharedNanos(long arg, long nanosTimeout) 嘗試以共享網要獲取，如果被中斷則中止，如果超過給定逾時期則失敗。
protected boolean	tryRelease(long arg) 嘗試設置狀態來反映獨佔網要下的釋放。
protected boolean	tryReleaseShared(long arg) 嘗試設置狀態來反映共享網要下的釋放。

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

getExclusiveOwnerThread, setExclusiveOwnerThread

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

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

建構子詳細資訊

AbstractQueuedLongSynchronizer

protected AbstractQueuedLongSynchronizer()

創建一個初始同步狀態為 0 的新 AbstractQueuedLongSynchronizer 實例。

方法詳細資訊

getState

protected final long getState()

返回同步狀態的當前值。此操作的記憶體語義 (memory semantics) 為 volatile 讀。

返回：

當前狀態值

setState

protected final void setState(long newState)

設置同步狀態的值。此操作的記憶體語義為 volatile 寫。

參數：

newState - 新的狀態值

compareAndSetState

protected final boolean compareAndSetState(long expect,
                                           long update)

如果當前狀態值等於預期值，則以原子方式將同步狀態設置為給定的更新值。此操作的記憶體語義為 volatile 寫和讀。

參數：

expect - 預期值

update - 新值

返回：

如果成功，則返回 true。返回 false 指示實際值與預期值不相等。

tryAcquire

protected boolean tryAcquire(long arg)

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

此方法總是由執行獲取的執行緒調用。如果此方法報告失敗，則 acquire 方法可以將執行緒加入佇列（如果它還沒有加入佇列），直到收到其他執行緒的釋放信號為止。可以使用此方法來實作 Lock.tryLock() 方法。

預設實作將拋出 UnsupportedOperationException。

參數：

arg - 獲取參數。此值總是傳遞給 acquire 方法的那個值，或者是保存在某個條件等待條目上的值。該值在其他方面沒有解釋，可以表示任何內容。

返回：

如果成功，則返回 true。在成功時，此物件已經被獲取。

拋出：

IllegalMonitorStateException - 如果獲取操作會將此同步器變為非法狀態。為了同步的正常運行，必須以統一的方式拋出此異常。

UnsupportedOperationException - 如果不支持獨佔網要

tryRelease

protected boolean tryRelease(long arg)

嘗試設置狀態來反映獨佔網要下的釋放。

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

預設實作將拋出 UnsupportedOperationException。

參數：

arg - 釋放參數。此值總是傳遞給 release 方法的那個值，或者是某個條件等待條目上的當前狀態值。該值在其他方面沒有解釋，可以表示任何內容。

返回：

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

拋出：

IllegalMonitorStateException - 如果釋放操作會將此同步器變為非法狀態。為了同步的正常運行，必須以統一的方式拋出此異常。

UnsupportedOperationException - 如果不支持獨佔網要

tryAcquireShared

protected long tryAcquireShared(long arg)

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

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

預設實作將拋出 UnsupportedOperationException。

參數：

arg - 獲取參數。此值總是傳遞給 acquire 方法的那個值，或者是保存在某個條件等待條目上的值。該值在其他方面沒有解釋，可以表示任何內容。

返回：

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

拋出：

IllegalMonitorStateException - 如果獲取操作會將此同步器變為非法狀態。為了同步的正常運行，必須以統一的方式拋出此異常。

UnsupportedOperationException - 如果不支持共享網要

tryReleaseShared

protected boolean tryReleaseShared(long arg)

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

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

預設實作將拋出 UnsupportedOperationException。

參數：

arg - 釋放參數。此值總是傳遞給 release 方法的那個值，或者是某個條件等待條目上的當前狀態值。該值在其他方面沒有解釋，可以表示任何內容。

返回：

如果此共享網要下的釋放允許等待的獲取（共享或獨佔）獲得成功，則返回 true；否則返回 false

拋出：

IllegalMonitorStateException - 如果釋放操作會將此同步器變為非法狀態。為了同步的正常運行，必須以統一的方式拋出此異常。

UnsupportedOperationException - 如果不支持共享網要

isHeldExclusively

protected boolean isHeldExclusively()

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

預設實作將拋出 UnsupportedOperationException。此方法只在 AbstractQueuedLongSynchronizer.ConditionObject 方法中進行內部調用，因此，如果不使用條件，則不需要定義它。

返回：

如果同步是以獨佔方式進行的，則返回 true；否則返回 false

拋出：

UnsupportedOperationException - 如果不支持這些條件

acquire

public final void acquire(long arg)

以獨佔網要獲取，忽略中斷。實作此方法要至少調用一次 tryAcquire(long)，並在成功時返回。否則，在成功之前，執行緒將加入佇列，可能反覆處於阻塞或未阻塞狀態，並一直調用 tryAcquire(long)。可以使用此方法來實作 Lock.lock() 方法。

參數：

arg - 獲取參數。此值被傳送給 tryAcquire(long)，但在其他方面沒有解釋，可以表示任何內容。

acquireInterruptibly

public final void acquireInterruptibly(long arg)
                                throws InterruptedException

以獨佔網要獲取，如果被中斷則中止。實作此方法首先要檢查中斷狀態，然後至少調用一次 tryAcquire(long)，並在成功時返回。否則，在成功或執行緒中斷之前，執行緒將加入佇列，可能反覆處於阻塞或未阻塞狀態，並一直調用 tryAcquire(long)。可以使用此方法來實作 Lock.lockInterruptibly() 方法。

參數：

arg - 獲取參數。此值被傳送給 tryAcquire(long)，但在其他方面沒有解釋，可以表示任何內容。

拋出：

InterruptedException - 如果當前執行緒被中斷

tryAcquireNanos

public final boolean tryAcquireNanos(long arg,
                                     long nanosTimeout)
                              throws InterruptedException

嘗試以獨佔網要獲取，如果被中斷則中止，如果超過給定逾時期則失敗。實作此方法首先要檢查中斷狀態，然後至少調用一次 tryAcquire(long)，並在成功時返回。否則，在成功、執行緒中斷或超過逾時期之前，執行緒將加入佇列，可能反覆處於阻塞或未阻塞狀態，並一直調用 tryAcquire(long)。可以使用此方法來實作 Lock.tryLock(long, TimeUnit) 方法。

參數：

arg - 獲取參數。此值被傳送給 tryAcquire(long)，但在其他方面沒有解釋，可以表示任何內容。

nanosTimeout - 等待的最大毫微秒數

返回：

如果獲取，則返回 true；如果逾時，則返回 false

拋出：

InterruptedException - 如果當前執行緒被中斷

release

public final boolean release(long arg)

以獨佔網要釋放。如果 tryRelease(long) 返回 true，則通過取消一個或多個執行緒的阻塞來實作此方法。可以使用此方法來實作 Lock.unlock() 方法。

參數：

arg - 釋放參數。此值被傳送給 tryRelease(long)，但在其他方面沒有解釋，可以表示任何內容。

返回：

從 tryRelease(long) 返回的值

acquireShared

public final void acquireShared(long arg)

以共享網要獲取，忽略中斷。實作此方法要至少調用一次 tryAcquireShared(long)，並在成功時返回。否則，在成功之前，執行緒將加入佇列，可能反覆處於阻塞或未阻塞狀態，並一直調用 tryAcquireShared(long)。

參數：

arg - 獲取參數。此值被傳送給 tryAcquireShared(long)，但在其他方面沒有解釋，可以表示任何內容。

acquireSharedInterruptibly

public final void acquireSharedInterruptibly(long arg)
                                      throws InterruptedException

以共享網要獲取，如果被中斷則中止。實作此方法首先要檢查中斷狀態，然後至少調用一次 tryAcquireShared(long)，並在成功時返回。否則，在成功或執行緒中斷之前，執行緒將加入佇列，可能反覆處於阻塞或未阻塞狀態，並一直調用 tryAcquireShared(long)。

參數：

arg - 獲取參數。此值被傳送給 tryAcquireShared(long)，但在其他方面沒有解釋，可以表示任何內容。

拋出：

InterruptedException - 如果當前執行緒被中斷

tryAcquireSharedNanos

public final boolean tryAcquireSharedNanos(long arg,
                                           long nanosTimeout)
                                    throws InterruptedException

嘗試以共享網要獲取，如果被中斷則中止，如果超過給定逾時期則失敗。實作此方法首先要檢查中斷狀態，然後至少調用一次 tryAcquireShared(long)，並在成功時返回。否則，在成功、執行緒中斷或超過逾時期之前，執行緒將加入佇列，可能反覆處於阻塞或未阻塞狀態，並一直調用 tryAcquireShared(long)。

參數：

arg - 獲取參數。此值被傳送給 tryAcquireShared(long)，但在其他方面沒有解釋，可以表示任何內容。

nanosTimeout - 等待的最大毫微秒數

返回：

如果獲取，則返回 true；如果逾時，則返回 false

拋出：

InterruptedException - 如果當前執行緒被中斷

releaseShared

public final boolean releaseShared(long arg)

以共享網要釋放。如果 tryReleaseShared(long) 返回 true，則通過取消一個或多個執行緒的阻塞來實作此方法。

參數：

arg - 釋放參數。此值被傳送給 tryReleaseShared(long)，但在其他方面沒有解釋，可以表示任何內容。

返回：

從 tryReleaseShared(long) 中返回的值

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 - 如果執行緒為 null

getQueueLength

public final int getQueueLength()

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

返回：

等待獲取的執行緒估計數

getQueuedThreads

public final Collection<Thread> getQueuedThreads()

返回一個 collection，該 collection 套件含正在等待獲取的執行緒。因為在建構此結果時，實際執行緒集可能動態地變化，所以返回的 collection 只是一個盡可能準確的估計值。所返回 collection 中的元素沒有特定的順序。設計此方法是為了便於建構子類別，提供更多的監視設施。

返回：

執行緒 collection

getExclusiveQueuedThreads

public final Collection<Thread> getExclusiveQueuedThreads()

返回一個 collection，該 collection 套件含正以獨佔網要等待獲取的執行緒。此方法的屬性與 getQueuedThreads() 相同，但它只返回那些因獨佔獲取而等待的執行緒。

返回：

執行緒 collection

getSharedQueuedThreads

public final Collection<Thread> getSharedQueuedThreads()

返回一個 collection，該 collection 套件含正以共享網要等待獲取的執行緒。此方法的屬性與 getQueuedThreads() 相同，但它只返回那些因共享獲取而等待的執行緒。

返回：

執行緒 collection

toString

public String toString()

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

覆寫：

類別 Object 中的 toString

返回：

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

owns

public final boolean owns(AbstractQueuedLongSynchronizer.ConditionObject condition)

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

參數：

condition - 條件

返回：

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

拋出：

NullPointerException - 如果 condition 為 null

hasWaiters

public final boolean hasWaiters(AbstractQueuedLongSynchronizer.ConditionObject condition)

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

參數：

condition - 條件

返回：

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

拋出：

IllegalMonitorStateException - 如果不進行獨佔同步

IllegalArgumentException - 如果給定條件與此同步器沒有關聯

NullPointerException - 如果 condition 為 null

getWaitQueueLength

public final int getWaitQueueLength(AbstractQueuedLongSynchronizer.ConditionObject condition)

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

參數：

condition - 條件

返回：

等待執行緒的估計數

拋出：

IllegalMonitorStateException - 如果不進行獨佔同步

IllegalArgumentException - 如果給定條件與此同步器沒有關聯

NullPointerException - 如果 condition 為 null

getWaitingThreads

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

返回一個 collection，該 collection 套件含那些正在與此同步器關聯的給定條件上等待的執行緒。因為在建構此結果時，實際執行緒集可能動態地變化，所以返回的 collection 只是一個盡可能準確的估計值。所返回 collection 中的元素沒有特定的順序。

參數：

condition - 條件

返回：

執行緒 collection

拋出：

IllegalMonitorStateException - 如果不進行獨佔同步

IllegalArgumentException - 如果給定條件與此同步器沒有關聯

NullPointerException - 如果 condition 為 null