java.util.concurrent.locks
类 ReentrantReadWriteLock.WriteLock

java.lang.Object
  java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock

所有已实现的接口：

Serializable, Lock

正在封闭类：

ReentrantReadWriteLock

public static class ReentrantReadWriteLock.WriteLock
extends Object
implements Lock, Serializable

ReentrantReadWriteLock.writeLock() 方法返回的锁。

另请参见：

序列化表格

构造方法摘要

protected

ReentrantReadWriteLock.WriteLock(ReentrantReadWriteLock lock) 子类使用的构造方法

方法摘要

int	getHoldCount() 查询当前线程保持写入锁的数量。
boolean	isHeldByCurrentThread() 查询此写入锁是否由当前线程保持。
void	lock() 获取写入锁。
void	lockInterruptibly() 获取写入锁，除非当前线程被中断。
Condition	newCondition() 返回一个用来与此 Lock 实例一起使用的 Condition 实例。
String	toString() 返回标识此锁及其锁状态的字符串。
boolean	tryLock() 仅当写入锁在调用期间未被另一个线程保持时获取该锁。
boolean	tryLock(long timeout, TimeUnit unit) 如果另一个线程在给定的等待时间内没有保持写入锁，并且当前线程未被中断，则获取写入锁。
void	unlock() 试图释放此锁。

从类 java.lang.Object 继承的方法

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

构造方法详细信息

ReentrantReadWriteLock.WriteLock

protected ReentrantReadWriteLock.WriteLock(ReentrantReadWriteLock lock)

子类使用的构造方法

参数：

lock - 外部锁对象

抛出：

NullPointerException - 如果锁为 null

方法详细信息

lock

public void lock()

获取写入锁。

如果另一个线程既没有保持读取锁也没有保持写入锁，则获取写入锁并立即返回，并将写入锁保持计数设置为 1。

如果当前线程已经保持写入锁，则保持计数增加 1，该方法立即返回。

如果该锁被另一个线程保持，出于线程调度的目的，将禁用当前线程，并且在获得写入锁之前，该线程将一直处于休眠状态，此时写入锁保持计数设置为 1。

指定者：

接口 Lock 中的 lock

lockInterruptibly

public void lockInterruptibly()
                       throws InterruptedException

获取写入锁，除非当前线程被中断。

如果另一个线程既没有保持读取锁也没有保持写入锁，则获取写入锁并立即返回，并将写入锁保持计数设置为 1。

如果当前线程已经保持此锁，则将保持计数加 1，该方法立即返回。

如果锁被另一个线程保持，则出于线程调度目的，禁用当前线程，并且在发生以下两种情况之一以前，该线程将一直处于休眠状态：

• 写入锁由当前线程获得；或者
• 其他某个线程中断当前线程。

如果当前线程获得写入锁，则将锁保持计数设置为 1。

如果当前线程：

• 在进入此方法时已经设置了该线程的中断状态；或者
• 在获取写入锁的同时被中断。

则抛出 InterruptedException，并且清除当前线程的已中断状态。

在此实现中，因为此方法是一个显式中断点，所以要优先考虑响应中断，而不是响应锁的普通获取或重入获取。

指定者：

接口 Lock 中的 lockInterruptibly

抛出：

InterruptedException - 如果当前线程是已中断的。

tryLock

public boolean tryLock()

仅当写入锁在调用期间未被另一个线程保持时获取该锁。

如果另一个线程既没有保持读取锁也没有保持写入锁，则获取写入锁并立即返回 true 值，并将写入锁保持计数设置为 1。即使已将此锁设置为使用公平排序策略，但是调用 tryLock() 仍将 立即获取锁（如果有可用的），不管其他线程当前是否正在等待写入锁。在某些情况下，此“闯入”行为可能很有用，即使它会打破公平性也如此。如果希望遵守此锁的公平设置，则使用 tryLock(0, TimeUnit.SECONDS) ，它几乎是等效的（它也检测中断）。

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

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

指定者：

接口 Lock 中的 tryLock

返回：

如果锁是自由的并且被当前线程获取，或者当前线程已经保持写入锁，则返回 true；否则返回 false。

tryLock

public boolean tryLock(long timeout,
                       TimeUnit unit)
                throws InterruptedException

如果另一个线程在给定的等待时间内没有保持写入锁，并且当前线程未被中断，则获取写入锁。

如果另一个线程既没有保持读取锁也没有保持写入锁，则获取写入锁并立即返回 true 值，并将写入锁保持计数设置为 1。如果为了使用公平的排序策略，已经设置此锁，并且其他线程都在等待写入锁，则不会 获取一个可用的锁。这与 tryLock() 方法相反。如果想使用一个允许闯入公平锁的定时 tryLock，那么可以将定时形式和不定时形式组合在一起：

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

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

如果锁被另一个线程保持，则出于线程调度目的，禁用当前线程，并且在发生以下三种情况之一以前，该线程将一直处于休眠状态：

• 写入锁由当前线程获得；或者
• 其他某个线程中断当前线程；或者
• 已超过指定的等待时间

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

如果当前线程：

• 在进入此方法时已经设置了该线程的中断状态；或者
• 在获取写入锁的同时被中断。

则抛出 InterruptedException，并且清除当前线程的已中断状态。

如果超出了指定的等待时间，则返回值为 false。如果该时间小于等于 0，则此方法根本不会等待。

在此实现中，因为此方法是一个显式中断点，所以要优先考虑响应中断，而不是响应锁的普通获取或重入获取，或者报告所用的等待时间。

指定者：

接口 Lock 中的 tryLock

参数：

timeou - 等待写入锁的时间

unit - timeout 参数的时间单位

返回：

如果锁是自由的并且由当前线程获取，或者当前线程已经保持写入锁，则返回 true；如果在获取该锁之前已经到达等待时间，则返回 false。

抛出：

InterruptedException - 如果当前线程被中断

NullPointerException - 如果时间单位为 null

unlock

public void unlock()

试图释放此锁。

如果当前线程保持此锁，则将保持计数减 1。如果保持计数现在为 0，则释放该锁。如果当前线程不是此锁的持有者，则抛出 IllegalMonitorStateException。

指定者：

接口 Lock 中的 unlock

抛出：

IllegalMonitorStateException - 如果当前线程没有保持此锁。

newCondition

public Condition newCondition()

返回一个用来与此 Lock 实例一起使用的 Condition 实例。

在使用内置监视器锁时，返回的 Condition 实例支持与 Object 的监视器方法（wait、notify 和 notifyAll）相同的用法。

• 如果当调用任何 Condition 方法时没有保持此写入锁，则抛出 IllegalMonitorStateException。（因为保持读取锁是独立于写入锁的，所以读取锁将不被检查或受影响。但是，在当前线程已经获取读取锁时，调用一个条件等待方法实质上一直是错误的做法，因为能够解除阻塞该方法的其他线程将无法获取写入锁。）
• 当调用等待条件方法并释放写入锁时，在它们返回之前，会重新获取写入锁，并将锁保持计数恢复到调用该方法时的值。
• 如果线程在等待时被中断，则等待将终止，并将抛出 InterruptedException，清除线程的已中断状态。
• 等待线程按 FIFO 顺序收到信号。
• 等待方法返回的线程重新获取锁的顺序与线程最初获取锁的顺序相同，在默认情况下，未指定此顺序，但对于公平 锁，它们更倾向于那些等待时间最长的线程。

指定者：

接口 Lock 中的 newCondition

返回：

Condition 对象

toString

public String toString()

返回标识此锁及其锁状态的字符串。该状态括在括号中，它包括字符串 "Unlocked" 或字符串 "Locked by"，后跟所拥有线程的名称。

覆盖：

类 Object 中的 toString

返回：

标识此锁及其锁状态的字符串

isHeldByCurrentThread

public boolean isHeldByCurrentThread()

查询此写入锁是否由当前线程保持。与 ReentrantReadWriteLock.isWriteLockedByCurrentThread() 效果相同。

返回：

如果当前线程保持此锁，则返回 true；否则返回 false

从以下版本开始：

1.6

getHoldCount

public int getHoldCount()

查询当前线程保持写入锁的数量。对于与解锁操作不匹配的每个锁操作，线程都会为其保持一个锁。与 ReentrantReadWriteLock.getWriteHoldCount() 效果相同。

返回：

当前线程保持的锁数量，如果当前线程没有保持此锁，则返回 0

从以下版本开始：

1.6