java.util.concurrent.locks

接口
类

java.util.concurrent.locks
类 ReentrantReadWriteLock.ReadLock

java.lang.Object
  继承者 java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock
所有已实现的接口：
Serializable, Lock
正在封闭类：
ReentrantReadWriteLock 
public static class ReentrantReadWriteLock.ReadLock
     

      extends 
      Object
     

     

      implements 
      Lock, 
      Serializable

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

另请参见：
序列化表格

构造方法摘要
protected ReentrantReadWriteLock.ReadLock(ReentrantReadWriteLock lock)
          子类使用的构造方法
 
方法摘要
 void lock()
          获取读取锁。
 void lockInterruptibly()
          获取读取锁，除非当前线程被中断。
 Condition newCondition()
          因为 ReadLocks 不支持条件，所以将抛出 UnsupportedOperationException。
 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.ReadLock

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

参数：
lock - 外部锁对象
抛出：
NullPointerException - 如果 lock 为 null
方法详细信息

lock

public void lock()
获取读取锁。

如果另一个线程没有保持写入锁，则获取读取锁并立即返回。

如果另一个线程保持该写入锁，出于线程调度目的，将禁用当前线程，并且在获取读取锁之前，该线程将一直处于休眠状态。

指定者：
接口 Lock 中的 lock

lockInterruptibly

public void lockInterruptibly()
                       throws InterruptedException
获取读取锁，除非当前线程被 中断。

如果另一个线程没有保持写入锁，则获取读取锁并立即返回。

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

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

如果当前线程：

  • 在进入此方法时已经设置了该线程的中断状态；或者
  • 在获取读取锁时被中断，
则抛出 InterruptedException，并且清除当前线程的已中断状态。

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

指定者：
接口 Lock 中的 lockInterruptibly
抛出：
InterruptedException - 如果当前线程是已中断的。

tryLock

public boolean tryLock()
仅当写入锁在调用期间未被另一个线程保持时获取读取锁。

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

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

指定者：
接口 Lock 中的 tryLock
返回：
如果获取了读取锁，则返回 true

tryLock

public boolean tryLock(long timeout,
                       TimeUnit unit)
                throws InterruptedException
如果另一个线程在给定的等待时间内没有保持写入锁，并且当前线程未被 中断，则获取读取锁。

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

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

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

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

如果获得了读取锁，则返回 true 值。

如果当前线程：

  • 在进入此方法时已经设置了该线程的中断状态；或者
  • 在获取读取锁时被中断，
则抛出 InterruptedException，并且清除当前线程的已中断状态。

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

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

指定者：
接口 Lock 中的 tryLock
参数：
timeou - 等待读取锁的时间
unit - timeout 参数的时间单位
返回：
如果获取了读取锁，则返回 true。
抛出：
InterruptedException - 如果当前线程被中断
NullPointerException - 如果时间单位为 null

unlock

public void unlock()
试图释放此锁。

如果读取者的数量目前为 0，则该锁可用于写入锁尝试。

指定者：
接口 Lock 中的 unlock

newCondition

public Condition newCondition()
因为 ReadLocks 不支持条件，所以将抛出 UnsupportedOperationException。

指定者：
接口 Lock 中的 newCondition
返回：
用于此 Lock 实例的新 Condition 实例
抛出：
UnsupportedOperationException - 总是如此

toString

public String toString()
返回标识此锁及其锁状态的字符串。括号中的状态包括字符串 "Read locks ="，后跟读取锁的数量。

覆盖：
类 Object 中的 toString
返回：
标识此锁及其锁状态的字符串。