ReentrantLock (Java Platform SE 8 )

java.lang.Object
- java.util.concurrent.locks.ReentrantLock

All Implemented Interfaces:

Serializable， Lock
```
public class ReentrantLock
extends Object
implements Lock, Serializable
```
一个可重入的互斥 Lock具有相同的基本行为和语义为隐式监控锁使用 synchronized方法和报表访问，但扩展功能。
一个ReentrantLock是由线程最后成功锁定，但尚未解锁它。一个线程调用lock将返回，成功获取锁，当锁不是由另一个线程拥有。如果当前线程已经拥有锁，该方法将立即返回。这可以使用方法isHeldByCurrentThread()检查，并getHoldCount()。

此类的构造函数接受一个可选的公平性参数。当设置true，争，锁青睐授予访问最长等待线程。否则，此锁不保证任何特定的访问顺序。使用许多线程访问的公平锁的程序可能会显示较低的整体吞吐量（即，比那些使用默认设置慢，往往要慢得多），但有较小的差异，在时间获得锁和保证缺乏饥饿。请注意，锁的公平性并不能保证线程调度的公平性。因此，使用一个公平锁的许多线程之一可能会获得它的连续多次，而其他活动线程不进展，而不是目前持有的锁。还要注意，不定时的tryLock()方法不尊重公平设置。如果锁是可用的，即使其他线程正在等待，它也会成功的。

这是推荐的做法总是紧跟一个电话lock与try块，最典型的是在前/后建设等：
```
 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }
```
除了实现Lock接口，这个类定义了用于检查锁的状态的一些public和protected方法。这些方法中的一些只是有用的仪器和监测。

这类的序列化的行为以同样的方式作为一个反序列化内置锁：锁处于解锁状态，无论其状态序列化时。

此锁支持同一线程的2147483647个递归锁的最大值。试图在Error超过这个限制的结果将从锁定的方法。
从以下版本开始：

一点五

另请参见：

Serialized Form

构造方法摘要

构造方法
Constructor and Description
`ReentrantLock()` 创建 `ReentrantLock`实例。
`ReentrantLock(boolean fair)` 创建具有给定的公平政策 `ReentrantLock`实例。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`int`	`getHoldCount()` 查询当前线程在这个锁上的数目。
`protected Thread`	`getOwner()` 返回该线程当前拥有该锁，或 `null`如果不拥有。
`protected Collection<Thread>`	`getQueuedThreads()` 返回一个包含可能等待获取此锁的线程的集合。
`int`	`getQueueLength()` 返回等待获取此锁的线程数的估计值。
`protected Collection<Thread>`	`getWaitingThreads(Condition condition)` 返回一个集合，包含可能在与此锁关联的给定条件下等待的线程集合。
`int`	`getWaitQueueLength(Condition condition)` 返回在与此锁关联的给定条件下等待的线程数的估计值。
`boolean`	`hasQueuedThread(Thread thread)` 查询给定线程是否正在等待获取此锁。
`boolean`	`hasQueuedThreads()` 查询是否有任何线程等待获取此锁。
`boolean`	`hasWaiters(Condition condition)` 查询是否有任何线程在与此锁关联的给定条件下等待。
`boolean`	`isFair()` 返回 `true`如果锁已经公平设置为true。
`boolean`	`isHeldByCurrentThread()` 查询如果这个锁是由当前线程持有的。
`boolean`	`isLocked()` 查询此锁是否由任何线程所持有。
`void`	`lock()` 获取锁。
`void`	`lockInterruptibly()` 获取该锁除非当前线程 interrupted。
`Condition`	`newCondition()` 返回一个用于这 `Lock`实例 `Condition`实例。
`String`	`toString()` 返回一个确定此锁的字符串，以及它的锁状态。
`boolean`	`tryLock()` 只有在调用时，它不是由另一个线程持有的锁。
`boolean`	`tryLock(long timeout, TimeUnit unit)` 获取该锁如果不是由另一个线程在等待时间和当前线程没有被 interrupted。
`void`	`unlock()` 试图释放这个锁。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - ReentrantLock
```
public ReentrantLock()
```
    创建 ReentrantLock实例。这相当于使用 ReentrantLock(false)。
  - ReentrantLock
```
public ReentrantLock(boolean fair)
```
    创建具有给定的公平政策 ReentrantLock实例。
    
    参数
    
    fair - true如果锁应该用一个公平的订货策略
- 方法详细信息
  - lock
```
public void lock()
```
    获取锁。
    获取锁，如果它不是由另一个线程持有的，并立即返回，设置锁保持计数为一。
    
    如果当前线程已经持有锁然后把计数递增的方法立即返回。
    
    如果锁由另一个线程持有，那么当前线程成为禁用线程调度的目的，并处于休眠状态，直到锁已被收购，在这一时间的锁保持计数设置为一个。
    
    Specified by:
    
    lock 接口 Lock
  - lockInterruptibly
```
public void lockInterruptibly()
                       throws InterruptedException
```
    获取该锁除非当前线程 interrupted。
    获取锁，如果它不是由另一个线程持有的，并立即返回，设置锁保持计数为一。
    
    如果当前线程已经持有这个锁然后把计数递增的方法立即返回。
    
    如果锁是由另一个线程持有的，那么当前线程成为禁用线程调度的目的，并处于休眠状态，直到两个事情发生：
    - 该锁是由当前线程获取的；或
    - 其他某个线程interrupts当前线程。
    如果锁定是由当前线程获取的，那么锁定计数将被设置为一个。
    
    如果当前线程：
    - 在该方法的入口上有它的中断状态；或
    - 是interrupted而获取锁，
    然后 InterruptedException投入和当前线程的中断状态被清除。
    在这个实现中，这种方法是一种明确的中断点，优先响应中断超过正常或折返的锁的获取。
    Specified by:
    
    lockInterruptibly 接口 Lock
    
    异常
    
    InterruptedException -如果当前线程被中断
  - tryLock
```
public boolean tryLock()
```
    只有在调用时，它不是由另一个线程持有的锁。
    获取该锁如果不是由另一个线程并立即返回的值true举行，设置锁持有数1。即使这把锁已设置为使用一个公平的订货政策，呼吁tryLock()将立即如果它是可用的获取锁，是否有其他线程正在等待锁。这种“闯”的行为在某些情况下可能是有用的，即使它打破了公平。如果你想尊重公平这把锁的设置，然后使用tryLock(0, TimeUnit.SECONDS) 几乎是等价的（它也检测到中断）。
    
    如果当前线程已经持有这个锁然后把计数递增的方法返回true。
    
    如果锁是由另一个线程然后这个方法会立即返回的值false。
    
    Specified by:
    
    tryLock 接口 Lock
    
    结果
    
    true如果锁是免费的，是由当前线程获取，或锁已经被当前线程持有；否则， false
  - tryLock
```
public boolean tryLock(long timeout,
                       TimeUnit unit)
                throws InterruptedException
```
    获取该锁如果不是由另一个线程在等待时间和当前线程没有被 interrupted。
    获取该锁如果不是由另一个线程并立即返回的值true举行，设置锁持有数1。如果这个锁已被设置为使用一个公平的订货政策，那么一个可用的锁将不会被收购，如果任何其他线程等待锁。与此形成对比的是，tryLock()方法。如果你想要一个定时tryLock不允许讨价还价在公平锁，然后结合定时和不定时的形式：
```
 if (lock.tryLock() ||
     lock.tryLock(timeout, unit)) {
   ...
 }
```
    如果当前线程已经持有这个锁然后把计数递增的方法返回true。
    
    如果锁由另一个线程持有，那么当前线程成为禁用线程调度的目的，并处于休眠状态，直到三个事情发生：
    - 该锁是由当前线程获取的；或
    - 其他某个线程interrupts当前线程；或
    - 指定的等待时间的流逝
    如果锁是后天再值true返回并且锁持有数设置为一个。
    
    如果当前线程：
    - 在该方法的入口上有它的中断状态；或
    - 是interrupted而获取锁，
    然后 InterruptedException投入和当前线程的中断状态被清除。
    如果指定的等待时间的流逝，然后false返回值。如果时间小于或等于零，该方法将不会等待在所有。
    
    在这个实现中，这种方法是一种明确的中断点，优先响应中断超过正常或折返的锁的获取，并在报告的等待时间的流逝。
    Specified by:
    
    tryLock 接口 Lock
    
    参数
    
    timeout -时间等待锁
    
    unit - timeout参数的时间单位
    
    结果
    
    true如果锁是免费的，是由当前线程获取，或锁已被当前线程举行；和 false如果等待的时间才可以获得的锁
    
    异常
    
    InterruptedException -如果当前线程被中断
    
    NullPointerException -如果时间单位为零
  - unlock
```
public void unlock()
```
    试图释放这个锁。
    如果当前线程持有这个锁然后把计数减少。如果保持计数现在为零，则释放锁。如果当前线程是不是这个锁持有者然后IllegalMonitorStateException抛出。
    
    Specified by:
    
    unlock 接口 Lock
    
    异常
    
    IllegalMonitorStateException -如果当前线程不持有这个锁
  - newCondition
```
public Condition newCondition()
```
    返回一个 Condition实例使用这 Lock实例。
    返回的Condition实例支持Object监测方法做同样的用法（wait，notify，和notifyAll）当使用内置监控锁。
    - 如果锁不举行任何的Condition waiting或signalling方法被调用，然后IllegalMonitorStateException抛出。
    - 当条件waiting方法称为锁被释放，在他们返回，锁和锁持有数重新恢复到什么时候的方法被称为。
    - 如果一个线程在等待再等待interrupted将终止，一个InterruptedException将抛出，和线程的中断状态将被清除。
    - 等待线程按照先进先出的顺序表示。
    - 从等待方法返回线程的锁重新排序为线程最初获取锁一样，这是在没有指定默认情况下，但公平锁偏爱那些线程一直等待时间最长。
    Specified by:
    
    newCondition 接口 Lock
    
    结果
    
    对象条件
  - getHoldCount
```
public int getHoldCount()
```
    查询当前线程在这个锁上的数目。
    线程有一个保持锁上的每个锁动作，不匹配的解锁动作。
    
    保持计数信息通常只用于测试和调试的目的。例如，如果一个特定部分的代码不应该输入与锁已经举行，那么我们可以断言这一事实：
```
 class X {
   ReentrantLock lock = new ReentrantLock();
   // ...
   public void m() {
     assert lock.getHoldCount() == 0;
     lock.lock();
     try {
       // ... method body
     } finally {
       lock.unlock();
     }
   }
 }
```
    结果
    
    如果此锁不由当前线程持有，则该锁上的锁的数量或为零
  - isHeldByCurrentThread
```
public boolean isHeldByCurrentThread()
```
    查询如果这个锁是由当前线程持有的。
    类似于Thread.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();
       }
   }
 }
```
    结果
    
    true如果当前线程持有这个锁和 false否则
  - isLocked
```
public boolean isLocked()
```
    查询此锁是否由任何线程所持有。这种方法被设计用于监视系统状态，而不是用于同步控制。
    
    结果
    
    true如果任何线程持有的锁，否则这 false
  - isFair
```
public final boolean isFair()
```
    返回 true如果锁已经公平设置为true。
    
    结果
    
    true如果锁已经公平设置为true
  - getOwner
```
protected Thread getOwner()
```
    返回该线程当前拥有该锁，或 null如果不拥有。当这个方法被一个不是所有者的线程调用时，返回值反映了当前锁定状态的最佳努力近似值。例如，业主可以随时 null即使有线程试图获取锁，但尚未这样做。这种方法的目的是方便的子类，提供更广泛的锁定监控设施的建设。
    
    结果
    
    业主，或 null如果不拥有
  - hasQueuedThreads
```
public final boolean hasQueuedThreads()
```
    查询是否有任何线程等待获取此锁。注意，因为取消随时可能发生，一个 true返回不保证其他线程会获得这个锁。这种方法的设计主要是用于监测系统状态。
    
    结果
    
    true如果可能有其他线程等待获取锁
  - hasQueuedThread
```
public final boolean hasQueuedThread(Thread thread)
```
    查询给定线程是否正在等待获取此锁。注意，因为取消随时可能发生，一个 true回报并不保证该线程会获得这个锁。这种方法的设计主要是用于监测系统状态。
    
    参数
    
    thread -螺纹
    
    结果
    
    true如果给定线程排队等待这个锁
    
    异常
    
    NullPointerException -如果线程是无效的
  - getQueueLength
```
public final int getQueueLength()
```
    返回等待获取此锁的线程数的估计值。价值只是一个估计值，因为线程的数量可以动态变化，而这一方法遍历内部数据结构。这种方法被设计用于监视系统状态，而不是用于同步控制。
    
    结果
    
    等待此锁的线程的估计数
  - getQueuedThreads
```
protected Collection<Thread> getQueuedThreads()
```
    返回一个包含可能等待获取此锁的线程的集合。由于实际的线程组在构建此结果时可能会动态更改，因此返回的集合只是一个最好的努力估计。返回的集合的元素没有特定的顺序。这种方法的目的是方便的子类，提供更广泛的监控设施的建设。
    
    结果
    
    线程集合
  - hasWaiters
```
public boolean hasWaiters(Condition condition)
```
    查询是否有任何线程在与此锁关联的给定条件下等待。注意，因为超时和中断可能发生在任何时间，一个 true收益并不能保证未来的 signal将唤醒所有线程。这种方法的设计主要是用于监测系统状态。
    
    参数
    
    condition -条件
    
    结果
    
    true如果有任何等待的线程
    
    异常
    
    IllegalMonitorStateException -如果这锁不举行
    
    IllegalArgumentException -如果给定的条件是不是与此相关的锁
    
    NullPointerException -如果条件是空的
  - getWaitQueueLength
```
public int getWaitQueueLength(Condition condition)
```
    返回在与此锁关联的给定条件下等待的线程数的估计值。注意，因为超时和中断可能发生在任何时间，估计只能作为一个上限对服务员的实际数量。这种方法被设计用于监视系统状态，而不是用于同步控制。
    
    参数
    
    condition -条件
    
    结果
    
    等待线程的估计数
    
    异常
    
    IllegalMonitorStateException -如果这锁不举行
    
    IllegalArgumentException -如果给定的条件是不是与此相关的锁
    
    NullPointerException -如果条件是空的
  - getWaitingThreads
```
protected Collection<Thread> getWaitingThreads(Condition condition)
```
    返回一个集合，包含可能在与此锁关联的给定条件下等待的线程集合。由于实际的线程组在构建此结果时可能会动态更改，因此返回的集合只是一个最好的努力估计。返回的集合的元素没有特定的顺序。这种方法的目的是方便的子类，提供更广泛的状态监测设施的建设。
    
    参数
    
    condition -条件
    
    结果
    
    线程集合
    
    异常
    
    IllegalMonitorStateException -如果这锁不举行
    
    IllegalArgumentException -如果给定的条件是不是与此相关的锁
    
    NullPointerException -如果条件是空的
  - toString
```
public String toString()
```
    返回一个确定此锁的字符串，以及它的锁状态。括号内的状态，包括字符串 "Unlocked"或字符串 "Locked by"随后拥有线程的 name。
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    确定该锁的字符串，以及它的锁状态

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class ReentrantLock

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Constructor Detail

ReentrantLock

ReentrantLock

方法详细信息

lock

lockInterruptibly

tryLock

tryLock

unlock

newCondition

getHoldCount

isHeldByCurrentThread

isLocked

isFair

getOwner

hasQueuedThreads

hasQueuedThread

getQueueLength

getQueuedThreads

hasWaiters

getWaitQueueLength

getWaitingThreads

toString