java.util.concurrent.locks.Lock 接口 源码

相关类图：

java.util.concurrent.locks.Lock 源码： 

package java.util.concurrent.locks;

import java.util.concurrent.TimeUnit;

public interface Lock {

    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

接口 Lock

全部已知实现类：

    ReentrantLock,

    ReentrantReadWriteLock.ReadLock, 

    ReentrantReadWriteLock.WriteLock

  Lock 实现提供了比使用 synchronized 方法和语句可得到的更普遍的锁定操做。此实现容许更灵活的结构，能够具备差异很大的属性，能够支持多个相关的 Condition 对象。

    锁是控制多个线程对共享资源进行访问的工具。一般，锁提供了对共享资源的独占访问。一次只能有一个线程得到锁，对共享资源的全部访问都须要首先得到锁。不过，某些锁可能容许对共享资源并发访问，如 ReadWriteLock 的读锁。

  synchronized 方法或语句的使用提供了对与每一个对象相关的隐式监视器锁的访问，但却强制全部锁获取和释放均要出如今一个块结构中：当获取了多个锁时，它们必须以相反的顺序释放，且必须在与全部锁被获取时相同的词法范围内释放全部锁。

    虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了不少，并且还帮助避免了不少涉及到锁的常见编程错误，但有时也须要以更为灵活的方式使用锁。例如，某些遍历并发访问的数据结果的算法要求使用 "hand-over-hand" 或 "chain locking"：获取节点 A 的锁，而后再获取节点 B 的锁，而后释放 A 并获取 C，而后释放 B 并获取 D，依此类推。Lock 接口的实现容许锁在不一样的做用范围内获取和释放，并容许以任何顺序获取和释放多个锁，从而支持使用这种技术。

    随着灵活性的增长，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数状况下，应该使用如下语句：

     Lock l = ...;
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }
 

    锁定和取消锁定出如今不一样做用范围中时，必须谨慎地确保保持锁定时所执行的全部代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。

  Lock 实现提供了使用 synchronized 方法和语句所没有的其余功能，包括提供了一个非块结构的获取锁尝试 (tryLock())、一个获取可中断锁的尝试 (lockInterruptibly()) 和一个获取超时失效锁的尝试 (tryLock(long, TimeUnit))。

  Lock 类还能够提供与隐式监视器锁彻底不一样的行为和语义，如保证排序、非重入用法或死锁检测。若是某个实现提供了这样特殊的语义，则该实现必须对这些语义加以记录。

    注意，Lock 实例只是普通的对象，其自己能够在 synchronized 代码块中做为目标使用。为了不混淆，建议除了在其自身的实现中以外，决不要在synchronized代码块中使用 Lock 实例做为锁对象。

方法摘要

void	lock()            获取锁。
void	lockInterruptibly()            若是当前线程未被中断，则获取锁。
Condition	newCondition()            返回绑定到此 Lock 实例的新 Condition 实例。
boolean	tryLock()            仅在调用时锁为空闲状态才获取该锁。
boolean	tryLock(long time, TimeUnit unit)            若是锁在给定的等待时间内空闲，而且当前线程未被中断，则获取锁。
void	unlock()            释放锁。

 

lock

void lock()

    获取锁。若是锁不可用，出于线程调度目的，将禁用当前线程，而且在得到锁以前，该线程将一直处于休眠状态。

 

lockInterruptibly

void lockInterruptibly() throws InterruptedException

    若是当前线程未被 中断，则获取锁。

    若是锁可用，则获取锁，并当即返回。

    若是锁不可用，出于线程调度目的，将禁用当前线程，而且在发生如下两种状况之一之前，该线程将一直处于休眠状态：

• 锁由当前线程得到，线程会被返回继续执行
• 其余线程中断当前线程，会抛出InterruptedException，并清除当前线程的已中断状态。

    抛出：

    InterruptedException - 若是在获取锁时，当前线程被中断（须要当前线程支持对锁获取的中断）。

 

tryLock

boolean tryLock()

    仅在调用时锁为空闲状态才获取该锁。

    若是锁可用，则获取锁，并当即返回值 true。若是锁不可用，则此方法将当即返回值 false。

    此方法的典型使用语句以下：

      Lock lock = ...;
      if (lock.tryLock()) {
          try {
              // manipulate protected state
          } finally {
              lock.unlock();
          }
      } else {
          // perform alternative actions
      }
 

    此用法可确保若是获取了锁，则会释放锁，若是未获取锁，则不会试图将其释放。

    返回：

        若是获取了锁，则返回 true；不然返回 false。

 

tryLock

boolean tryLock(long time, TimeUnit unit) throws InterruptedException

    若是锁在给定的等待时间内空闲，而且当前线程未被中断，则获取锁。

    若是锁可用，则此方法将当即返回值 true。

    若是锁不可用，出于线程调度目的，将禁用当前线程，而且在发生如下三种状况之一前，该线程将一直处于休眠状态：

• 锁由当前线程得到，此时当前线程再也不休眠，当即返回值 true；
• 其余某个线程中断当前线程，而且当前线程支持对锁获取的中断，则将抛出 InterruptedException，并会清除当前线程的已中断状态；
• 已超过指定的等待时间，此时当前线程再也不休眠，当即返回值 false。若是 time 小于等于 0，该方法将彻底不等待。

    参数：

    time - 等待锁的最长时间

    unit - time 参数的时间单位

    返回：

        若是在等待时间内得到了锁，则返回 true；若是在获取锁前超过了等待时间，则返回 false

    抛出：

    InterruptedException - 若是在获取锁时，当前线程被中断（须要当前线程支持对锁获取的中断）

 

unlock

void unlock()

    释放锁。一般只有锁的保持者能够释放它，若是违背了这个限制，可能会抛出（未经检查的）异常。

 

newCondition

Condition newCondition()

    返回绑定到此 Lock 实例的新 Condition 实例。

    在等待条件前，锁必须由当前线程保持。调用 Condition.await() 将在等待前以原子方式释放锁，并在等待返回前从新获取锁。

    返回：

        用于此 Lock 实例的新 Condition 实例

    抛出：

    UnsupportedOperationException - 若是此 Lock 实现不支持条件