【JDK1.8源码阅读】 JUC锁基础源码实现分析整理（四）

JUC（java.util.concurrent）下定义了JDK关于锁相关的框架。整体锁框架可参照 参考文章的一张图：

对其中每个工具类介绍如下：

Lock

Lock为接口类型，Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的Condition对象。
Lock接口的基本API定义如下：

public interface Lock {
    // 堵塞获取锁，直到拿到锁结束调用
    void lock();

    // 可被打断地获取锁，相对于lock本方法可以响应中断，打断当前堵塞线程，抛出InterruptedException
    void lockInterruptibly() throws InterruptedException;

    // 非堵塞尝试获取锁，如果获取失败，返回false，获取成功返回true
    boolean tryLock();

    // 在指定时间内尝试获取锁，有3种情况会返回：
    // 1. 在超时时间内获得锁，返回true
    // 2. 在超时时间内被打断，抛出InterruptedException
    // 3. 超时时间内未获得锁，结束调用返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    // 解锁
    void unlock();

    // 获取等待通知组件，和当前锁对象绑定，只有当前线程获得锁后，才能调用该组件的wait()方法，调用成功后，堵塞等待恢复并释放锁。
    Condition newCondition();
}

Condition

Condition为接口类型，它将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。可以通过await(),signal()来休眠/唤醒线程。源码定义如下：

public interface Condition {
    // 堵塞等待被唤醒，可被打断
    void await() throws InterruptedException;

    // 堵塞等待被唤醒，不可被打断
    void awaitUninterruptibly();

    // 等待指定时间，超时后唤醒，可被打断
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    // 等待指定时间，超时后唤醒，可被打断
    boolean await(long time, TimeUnit unit) throws InterruptedException;

    // 等待直到指定时间后唤醒，可被打断
    boolean awaitUntil(Date deadline) throws InterruptedException;

    // 通知其他和当前锁对象绑定的任一Condition
    void signal();

    // 通知所有和当前锁对象绑定的任一Condition
    void signalAll();
}

ReadWriteLock

ReadWriteLock为接口类型， 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。源码定义如下：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

AbstractOwnableSynchonizer

AbstractOwnableSynchonizer为抽象类，可以由线程以独占方式拥有的同步器。此类为创建锁和相关同步器提供了基础。AbstractOwnableSynchronizer类本身不管理或使用此信息。但是，子类和工具可以使用适当维护的值帮助控制和监视访问以及提供诊断。基础实现如下：

abstract class AbstractOwnableSynchronizer
        implements java.io.Serializable {

    /**
     * 空实现供子类调用
     */
    protected AbstractOwnableSynchronizer() { }

    /**
     * 记录当前独占线程
     */
    private transient Thread exclusiveOwnerThread;

    /**
     * 设置独占线程
     */
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    /**
     * 获取当前
     */
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

AbstractQueuedLongSynchronizer

AbstractQueuedLongSynchronizer为抽象类，以 long 形式维护同步状态的一个 AbstractQueuedSynchronizer 版本。此类具有的结构、属性和方法与 AbstractQueuedSynchronizer 完全相同，但所有与状态相关的参数和结果都定义为 long 而不是 int。当创建需要 64 位状态的多级别锁和屏障等同步器时，此类很有用。

AbstractQueuedSynchonizer

AbstractQueuedSynchonizer为抽象类，其为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架。此类的设计目标是成为依靠单个原子 int 值来表示状态的大多数同步器的一个有用基础。

LockSupport

LockSupport为常用类，用来创建锁和其他同步类的基本线程阻塞原语。LockSupport的功能和"Thread中的 Thread.suspend()和Thread.resume()有点类似"，LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程。但是park()和unpark()不会遇到“Thread.suspend 和 Thread.resume所可能引发的死锁”问题。即先调用unpark,再调用park,程序也能正常运行。

LockSupport中提供的堵塞唤醒方法如下所示：

在Java 6中，LockSupport增加了park(Object blocker)、parkNanos(Object blocker,long nanos)和parkUntil(Object blocker,long deadline)3个方法，用于实现阻塞当前线程的功能，其中参数blocker是用来标识当前线程在等待的对象（以下称为阻塞对象），该对象主要用于问题排查和系统监控。

ReentrantLock

ReentrantLock为常用类，它是一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

ReentrantReadWriteLock

ReentrantReadWriteLock是读写锁接口ReadWriteLock的实现类，它包括Lock子类ReadLock和WriteLock。ReadLock是共享锁，WriteLock是独占锁。

参考

1. http://www.cnblogs.com/leesf456/p/5344133.html
2. Java并发编程的艺术