版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/LiuRenyou/article/details/78338102
具有相同基本的可重入互斥互斥锁
*行为和语义作为隐式监视器锁使用
{代码同步}方法和语句，但具有扩展名
*能力。
*
* <BR>一{ @代码}是< EM > ReentrantLock拥有< / EM >的螺纹上
*成功锁定，但尚未解锁。一个线程调用
{代码锁定}将返回，成功获取锁，当
*锁不是另一个线程拥有的。该方法将返回
*如果当前线程已经拥有锁，请立即执行。这可以
*检查使用方法{@链接# isheldbycurrentthread }，和{”链接
* # getholdcount }。
*
*这个类的构造函数接受一个可选的
*公平性<参数>。当设置{代码}时，在
*争用，锁允许授予对最长等待的访问权
*螺纹。否则，此锁不能保证任何特定
*访问顺序。使用许多线程访问的公平锁的程序
*可能显示较低的总吞吐量（即较慢）；
*比默认设置要慢，但要小一些。
*在获得锁和保证缺乏时间的差异
*饥饿。但是请注意，锁的公平性不能保证。
*线程调度的公平性。因此，许多线程中的一个使用
*公平锁可以多次获得，而其他
*活动线程没有进展，当前不支持
*锁。
*注意，不计时{@链接# trylock() trylock }方法不
*尊重公平设置。如果锁成功
*即使其他线程在等待，也可用。
*
*建议立即执行< < > > > > >
*用一个{代码}块来调用{代码锁定}，最多
*通常在前/后施工中，例如：
class X {
* private final ReentrantLock lock = new ReentrantLock();
* // ...
*
* public void m() {
* lock.lock(); // block until condition holds
* try {
* // ... method body
* } finally {
* lock.unlock()
* }
* }
* }
除了实现{链接锁}接口，
*类中定义的方法的代码}和{ @锁
* { @代码getlockqueuelength }，以及一些相关的
{代码保护}访问方法，可能对
*仪器和监测。
*
*这个类的序列化行为与内置的方式相同。
*锁：一个反序列化，锁在锁定状态，无论
*序列化时的状态。
*
*此锁支持最多2147483647个递归锁。
*同一线程。超过此限制的尝试导致
{链接错误}从锁定方法抛出。
/**
获取锁，如果它不被另一个线程持有并返回
*立即将锁定计数设置为1。
*如果当前线程已经持有锁，则保持
*计数递增1，该方法立即返回。
*如果锁由另一个线程持有，则
*线程调度时禁用当前线程
*目的和谎言处于休眠状态，直到获得锁为止，
锁存计数设置为1。
**/
public void lock() {
sync.lock();
}
/**
获取该锁除非当前线程
* { @ linkplain螺纹#中断中断}。
*如果它不被另一个线程持有并返回，则获取锁。
*立即设置锁持有数1。
*如果当前线程已经持有此锁，则持有计数
*递增1，方法立即返回。
*
* <BR>如果锁被另一个线程然后
*线程调度时禁用当前线程
*目的和谎言休眠，直到其中一件事发生：
* < UL >
* <李>锁获取当前线程；或
* <李>其他线程{ @ linkplain螺纹#中断}的
*当前线程。
*如果当前线程获取锁，则锁持有。
*计数设置为1。
*如果当前线程：
* < UL >
* <在该方法的条目中设置了中断状态；或
*
* <李>是{ @ linkplain螺纹#中断中断}而获取锁，
*然后抛出InterruptedException } { @链接与当前线程的
*已中断状态已清除。
*在这个实现中，因为这个方法是显式的。
*中断点，优先考虑响应
*中断正常或可重入锁的获取。
* @抛出InterruptedException如果当前线程被中断
**/
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
/**
只有在其他线程不被锁时才获取锁。
*调用。
*
*如果它不被另一个线程持有，则获取锁。
*立即返回值{代码}，设置
*锁定计数为1。即使该锁已设置为使用
*公平的订货策略，调用代码trylock() } { @ < EM >将< / EM >
*立即获得锁，如果它是可用的，不管是否
*其他线程正在等待锁。
*这"；闯"；行为可以在一定程度上是有用的
*环境，即使它打破公平。如果你想要荣誉
*此锁的公平设置，然后使用
* {@链接# trylock（长、timeunit）trylock（0，timeunit。秒）}
*这几乎是等效的（它也检测中断）。
*
*如果当前线程已经持有此锁，则保持
*计数递增1，方法返回{代码真}。
*
*如果锁由另一个线程持有，则此方法将返回。
*立即使用值{代码false }。
*
*如果返回锁是空闲的，并且返回的代码为真}，则由
*当前线程，或锁已被当前持有
*线程；{代码false }否则
**/
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
/**
获取锁，如果它不被给定线程中的另一个线程锁住。
*等待时间和当前线程没有
* { @ linkplain螺纹#中断中断}。
*
*如果它不被另一个线程持有并返回，则获取锁。
*立即用值{代码}，设置锁保持计数
*对一。如果该锁已设置为使用公平排序策略，则
*如果任何其他线程都无法获得可用的锁< > >
*在等锁。与此形成对比的是，{@链接# trylock() }
*方法。如果你想要一个定时{ @代码不允许讨价还价在trylock }
*一个公平的锁，然后结合定时和非计时形式在一起：
*
* <预>如果（锁。trylock() | |锁。trylock（超时，单位））{…}
* <前>
*
*如果当前线程
*已持有此锁，然后持有计数递增1和
*方法返回{代码真}。
*
* <BR>如果锁被另一个线程然后
*线程调度时禁用当前线程
*目的和谎言潜伏，直到三件事之一发生：
*
* < UL >
*
* <李>锁获取当前线程；或
*
* <李>其他线程{ @ linkplain螺纹#中断}
*当前线程；或
*
* <李>指定的等待时间的流逝
*
**
*
* < >如果获取锁，则返回值{代码真}并
*锁定计数设置为1。
*
*如果当前线程：
*
* < UL >
*
* <在该方法的条目中设置了中断状态；或
*
* <李>是{ @ linkplain螺纹#中断中断}而
*获取锁，
*
**
*然后抛出InterruptedException } { @链接与当前线程的
*已中断状态已清除。
*
* <BR>如果指定的等待时间的流逝然后值{ @代码错误}
*返回。如果时间是小于或等于零，方法
*不会等待。
*
*在这个实现中，因为这个方法是显式的。
*中断点，优先考虑响应
*中断对锁的正常或重入获取，以及
*在报告的等待时间的流逝。
*
* @param超时时间等待锁
* @param单位时间单位的超时参数
*如果返回锁是空闲的，并且返回的代码为真}，则由
*当前线程，或锁已被当前持有
*线程和{代码}如果等待时间经过之前
*可以获得锁。
* @抛出InterruptedException如果当前线程被中断
* @抛出NullPointerException异常如果时间单位为零
**/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
/**
释放此锁的尝试。
*
*如果当前线程是此锁的持有者，则保持
*计数减少。如果持有计数现在是零，那么锁
*被释放。如果当前线程不是这个的持有者
*锁然后{@链接illegalmonitorstateexception }扔。
*
* @投illegalmonitorstateexception如果当前线程不
*拿着这个锁
**/
public void unlock() {
sync.release(1);
}
/**
返回一个链路状态} { @实例使用这
{链接锁}实例。
*
*返回的连接条件}实例支持相同的
*与{链接对象}监视方法（{链接）一起使用
*对象# wait()等}，{“链接对象#通知通知}，{”链接，
*对象# notifyAll notifyAll }）当使用内置
*监视锁。
*
* < UL >
*
< < > >如果任何锁条件不存在时，该锁不被保留
* { @ linkplain await() }或{等条件# @ linkplain
*条件#信号信号}的方法被调用，然后{@链接
* illegalmonitorstateexception }扔。
* <li>当条件{ @ linkplain条件# await()等待}
*方法被称为锁释放，并在他们之前。
*返回，锁和锁持有计数恢复恢复
*当方法被调用时。
* <li>如果线程是{ @ linkplain螺纹#中断中断}
*等待时，等待将终止，{链接
*会抛出InterruptedException }，和线程的
*中断状态将被清除。
* <李>等待线程发出信号，按照先进先出的顺序。
* <李>订购锁的线程返回重新定位
*等待方法与最初的线程相同。
*获取锁，在默认情况下未指定，
*但是，对于那些不公平的人来说，锁有利于那些已经存在的线程。
*等待最长。
*返回条件对象
**/
public Condition newCondition() {
return sync.newCondition();
}
释放此锁的尝试。
*
*如果当前线程是此锁的持有者，则保持
*计数减少。如果持有计数现在是零，那么锁
*被释放。如果当前线程不是这个的持有者
*锁然后{@链接illegalmonitorstateexception }扔。
*
* @投illegalmonitorstateexception如果当前线程不