ReentrantLock

ReentrantLock

ReentrantLock ()

创建一个ReentrantLock的实例。 这相当于使用ReentrantLock(false) 。

ReentrantLock

ReentrantLock (boolean fair)

使用给定的公平策略创建 ReentrantLock的实例。

getHoldCount

int getHoldCount ()

查询当前线程在该锁上的保留数量。

一个线程对每个锁定操作都有一个锁定，而不是通过解锁操作进行匹配。

保持计数信息通常仅用于测试和调试目的。 例如，如果某段代码不应该与已经存在的锁一起输入，那么我们可以断言：

 class X {
   ReentrantLock lock = new ReentrantLock();
   // ...
   public void m() {
     assert lock.getHoldCount() == 0;
     lock.lock();
     try {
       // ... method body
     } finally {
       lock.unlock();
     }
   }
 }

getQueueLength

int getQueueLength ()

返回等待获取此锁的线程数的估计值。 该值仅为估计值，因为在此方法遍历内部数据结构时，线程数可能会动态变化。 此方法设计用于监视系统状态，而不是用于同步控制。

getWaitQueueLength

int getWaitQueueLength (Condition condition)

返回等待与此锁关联的给定条件的线程数的估计值。 请注意，因为超时和中断可能随时发生，所以估计仅作为服务员实际数量的上限。 此方法设计用于监视系统状态，而不是用于同步控制。

hasQueuedThread

boolean hasQueuedThread (Thread thread)

查询给定线程是否正在等待获取此锁。 请注意，因为取消可能随时发生， true返回true并不能保证此线程将获得此锁定。 此方法主要用于监视系统状态。

hasQueuedThreads

boolean hasQueuedThreads ()

查询是否有线程正在等待获取此锁。 请注意，因为取消可能随时发生，所以true返回不能保证任何其他线程都会获取此锁。 此方法主要用于监视系统状态。

hasWaiters

boolean hasWaiters (Condition condition)

查询是否有线程正在等待与此锁相关的给定条件。 请注意，因为超时和中断可能随时发生，所以true返回不能保证将来signal将唤醒任何线程。 此方法主要用于监视系统状态。

isFair

boolean isFair ()

如果此锁定公平设置为true，则返回 true 。

isHeldByCurrentThread

boolean isHeldByCurrentThread ()

查询此锁是否由当前线程保存。

类似于内置监视器锁的方法holdsLock(Object) ，此方法通常用于调试和测试。 例如，一个只应在被锁定时才被调用的方法可以断言情况如此：

 class X {
   ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
       assert lock.isHeldByCurrentThread();
       // ... method body
   }
 }

它也可以用来确保以不可重入方式使用可重入锁，例如：

 class X {
   ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
       assert !lock.isHeldByCurrentThread();
       lock.lock();
       try {
           // ... method body
       } finally {
           lock.unlock();
       }
   }
 }

isLocked

boolean isLocked ()

查询这个锁是否被任何线程持有。 此方法设计用于监视系统状态，而不是用于同步控制。

lock

void lock ()

获取锁定。

如果该锁没有被另一个线程占用并且立即返回，则获取该锁，将锁定保持计数设置为1。

如果当前线程已经保存了锁，那么保持计数会加1，并且该方法立即返回。

如果锁由另一个线程保存，则当前线程因为线程调度目的而变为禁用状态，并处于休眠状态，直到获取锁，此时锁定保持计数设置为1。

lockInterruptibly

void lockInterruptibly ()

获取锁定，除非当前线程为 interrupted 。

如果该锁没有被另一个线程占用并且立即返回，则获取该锁，将锁定保持计数设置为1。

如果当前线程已经保存了这个锁，那么保持计数加1，并且该方法立即返回。

如果锁由另一个线程保存，则当前线程因为线程调度目的而被禁用，并且处于休眠状态，直到发生以下两件事之一：

• The lock is acquired by the current thread; or
• Some other thread interrupts the current thread.

如果锁由当前线程获取，则锁定保持计数设置为1。

如果当前线程：

• has its interrupted status set on entry to this method; or
• is interrupted while acquiring the lock,

在这个实现中，由于这个方法是一个明确的中断点，因此优先考虑响应正常或重入锁的中断。

newCondition

Condition newCondition ()

返回 Condition与此使用实例 Lock实例。

返回 Condition实例支持相同的用途为做 Object监视器方法（ wait ， notify ，并 notifyAll与使用时）内置监视器锁定。

• If this lock is not held when any of the Condition waiting or signalling methods are called, then an IllegalMonitorStateException is thrown.
• When the condition waiting methods are called the lock is released and, before they return, the lock is reacquired and the lock hold count restored to what it was when the method was called.
• If a thread is interrupted while waiting then the wait will terminate, an InterruptedException will be thrown, and the thread's interrupted status will be cleared.
• Waiting threads are signalled in FIFO order.
• The ordering of lock reacquisition for threads returning from waiting methods is the same as for threads initially acquiring the lock, which is in the default case not specified, but for fair locks favors those threads that have been waiting the longest.

toString

String toString ()

返回标识此锁定的字符串以及其锁定状态。 括号中的状态包括字符串"Unlocked"或字符串"Locked by"后面跟随拥有线程的name 。

tryLock

boolean tryLock ()

只有在调用时它未被另一个线程占用的情况下才会获取该锁。

如果该锁未被另一个线程true ，则获取锁，并立即返回值true ，将锁定保持计数设置为1。 即使这个锁被设置为使用公平的订购策略，对tryLock()的调用也会立即获得该锁（如果该锁可用），无论其他线程当前是否正在等待锁定。 这种“bar”“行为在某些情况下可能会有用，即使它违背公平。 如果您想要遵守此锁的公平性设置，请使用tryLock(0, TimeUnit.SECONDS) ，它几乎相同（它也会检测到中断）。

如果当前线程已经拥有此锁，则保持计数将加1并且方法返回 true 。

如果锁由另一个线程保存，则此方法将立即返回值 false 。

tryLock

boolean tryLock (long timeout, 
                TimeUnit unit)

如果它在给定的等待时间内没有被另一个线程 占用 ，并且当前线程不是 interrupted ，则获取该锁。

如果该锁没有被另一个线程true ，则获取该锁，并立即返回值true ，将锁定保持计数设置为1。 如果此锁已设置为使用公平的订购策略，那么如果有其他线程正在等待锁， 则不会获取可用的锁。 这与tryLock()方法相反。 如果你想要一个允许公平锁定的定时tryLock ，那么将定时和tryLock表格组合在一起：

 if (lock.tryLock() ||
     lock.tryLock(timeout, unit)) {
   ...
 }

如果当前线程已经拥有此锁定，则保持计数会加1，并返回 true 。

如果锁由另一个线程保存，则当前线程因为线程调度目的而被禁用，并且处于休眠状态，直到发生三件事之一：

• The lock is acquired by the current thread; or
• Some other thread interrupts the current thread; or
• The specified waiting time elapses

如果获取锁定，则返回值 true ，并将锁定保持计数设置为1。

如果当前线程：

• has its interrupted status set on entry to this method; or
• is interrupted while acquiring the lock,

如果经过了指定的等待时间，则返回值false 。 如果时间小于或等于零，该方法将不会等待。

在该实现中，由于该方法是明确的中断点，因此优先考虑响应正常或重入锁获取的中断，并报告等待时间的过去。

unlock

void unlock ()

试图释放此锁。

如果当前线程是该锁的持有者，则保持计数递减。 如果保持计数现在为零，则锁定被释放。 如果当前线程不是该锁的持有者，则抛出IllegalMonitorStateException 。

getOwner

Thread getOwner ()

返回当前拥有此锁的线程，如果不是，则返回null 。 当此方法由非所有者的线程调用时，返回值反映当前锁状态的尽力而为的近似值。 例如，即使有线程试图获取锁但尚未这样做，拥有者也可能暂时为null 。 该方法旨在便于建造提供更广泛锁定监控设施的子类。

getQueuedThreads

Collection<Thread> getQueuedThreads ()

返回包含可能正在等待获取此锁的线程的集合。 因为实际的一组线程可能会在构造这个结果时动态地改变，所以返回的集合只是一个尽力而为的估计。 返回的集合的元素没有特定的顺序。 该方法旨在促进提供更广泛监测设施的子类的构建。

getWaitingThreads

Collection<Thread> getWaitingThreads (Condition condition)

返回包含那些可能正在等待与此锁相关的给定条件的线程的集合。 因为实际的一组线程可能会在构造这个结果时动态地改变，所以返回的集合只是一个尽力而为的估计。 返回的集合的元素没有特定的顺序。 这种方法旨在促进提供更广泛的状态监测设施的子类的构建。