一、内部原理

　　类继承结构

　　Lock package相关API继承结构，忽略掉了一些类，以便观察其特点：

　　ReentrantLock和 ReentrantReadWriteLock都是借助内部类Sync来实现Lock接口。ReentrantReadWriteLock没有直接实现Lock接口而是内置了读锁-ReadLock和写锁-WriteLock分别实现Lock接口。

　　Sync包含两个子类：FairSync(公平锁)，NonfairSync(非公平锁);在构建ReentrantLock和 ReentrantReadWriteLock对象时，可通过带有参数的构造函数指定是否采用公平锁;不指定时默认是非公平锁。Sync类是从·AbstractQueuedSynchronizer继承而来。

　　抽象队列同步器AQS

　　AbstractQueuedSynchronizer简称AQS，Doug Lea大师创作，用来构建锁或者其他同步组件的基础框架类，除了ReentrantLock和ReentrantReadWriteLock还有很多其他的并发工具类的实现都依赖于AQS;CountDownLatch、CyclicBarrier、Semaphore等都是基于AQS实现。(本章主要分析AQS的源码，下一章可以分析下这些类的用法)。

　　AQS为同步状态的原子性管理、线程的阻塞和解除阻塞以及排队提供了一种通用机制。基于模板方法模式设计，在使用时需要通过组合一个AQS的子类并重写其同步资源获取和释放逻辑方法tryAcquire()和tryRelease()。

　　AQS的使用思路很简单，在有线程获取锁时，调用子类tryAcquire()尝试获取锁，在获取失败时，将线程加入到一个基于CLH锁结构实现的等待队列中，当持有锁的线程执行完操作释放锁时，调用子类的tryRelease()释放锁资源，并唤醒等待队列中的下一个线程开始获取锁。

　　主要API

　　同步状态管理

　　int getState(): 获取同步状态

　　void setState(): 设置同步状态

　　boolean compareAndSetState(int expect, int update)：基于CAS，原子设置当前状态

　　两组用于实现独占模式和共享模式的抽象方法。

　　独占模式锁操作

　　acquire(int) ：尝试获取争用资源，如果未获取到，当前线程将进入等待队列。

　　tryAcquire()：争用资源逻辑的具体实现，必须由具体的AQS使用者去实现。

　　acquireInterruptibly()：支持中断的获取acquire操作

　　release()：当前线程释放争用资源，并唤醒等待队列中的其他线程进入争抢。

　　tryRelease()：释放争用资源的具体实现，必须由具体的AQS使用者去实现

　　共享模式锁操作

　　acquireShared()：acquire的共享模式版本。

　　tryAcquireShared()：tryAcquire的共享模式版本。

　　acquireSharedInterruptibly()：acquireInterruptibly的共享模式版本

　　releaseShared()：release的共享模式版本

　　tryReleaseShared()：tryRelease的共享模式版本

　　源码

　　内部等待队列Node

　　static final class Node {

　　static final Node SHARED = new Node(); //共享模式

　　static final Node EXCLUSIVE = null; //独占模式

　　Node nextWaiter; //独占或共享模式标记

　　//等待状态常量定义

　　static final int CANCELLED = 1; //取消

　　static final int SIGNAL = -1; //通知

　　static final int CONDITION = -2; //条件等待

　　static final int PROPAGATE = -3; //传播

　　volatile int waitStatus; //等待状态属性

　　volatile Node prev; //前驱节点

　　volatile Node next; //后继节点

　　volatile Thread thread; //节点所封装的线程

　　//判断节点是否处于共享模式

　　final boolean isShared() {

　　return nextWaiter == SHARED;

　　}

　　//获取前驱节点，为空时抛出异常

　　final Node predecessor() throws NullPointerException {

　　Node p = prev;

　　if (p == null) {

　　throw new NullPointerException();

　　} else {

　　return p;

　　}

　　}

　　//以独占或共享模式构造一个线程节点，由AQS的addWaiter调用

　　Node(Thread thread, Node mode) {

　　this.nextWaiter = mode;

　　this.thread = thread;

　　}

　　//Condition模式下使用此构造函数

　　Node(Thread thread, int waitStatus) {

　　this.waitStatus = waitStatus;

　　this.thread = thread;

　　}

　　}

　　独占锁的获取acquire()

　　/**

　　* !tryAcquire(arg):

　　* 首先调用其子类(实际的AQS使用者)尝试获取锁，获取成功函数就直接返回了。

　　* acquireQueued(addWaiter(Node.EXCLUSIVE), arg)): 子类未获取到锁时：

　　* 通过addWaiter() 以独占模式将当前线程封装成为Node节点并执行必要的初始化。

　　* 通过acquireQueued()根据节点在队列中的位置，执行获取锁或者是阻塞线程操作

　　*/

　　public final void acquire(int arg) {

　　if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

　　selfInterrupt();

　　}

　　/**

　　* 1. 将当前线程封装为node节点。

　　* 2. 如队列未初始化，则初始化队列，并把当前线程节点加入队列末尾。

　　* 3. 如果队列已经初始化(已经存在等待锁的其他线程节点)，则将当前线程节点直接加入到队里末尾

　　* 4. 返回代表当前线程的Node节点。

　　*/

　　private Node addWaiter(Node mode) {

　　Node node = new Node(Thread.currentThread(), mode); // 将当前线程封装成为Node节点。

　　Node pred = tail; // pred指向队列末尾

　　if (pred != null) { // 如果队列末尾元素不为空

　　node.prev = pred;

　　// CAS更新队列末尾指向当前线程节点。更新成功后，将旧队列末尾的后驱指向当前线程节点，返回当前线程节点。

　　if (compareAndSetTail(pred, node)) {

　　pred.next = node;

　　return node;

　　}

　　}

　　enq(node); //如果队列为空，则初始化队列，然后将当前线程节点加入队列

　　return node;

　　}

　　/**

　　* 如果队列未初始化，则使用一个无指向的Node作为队列头，将当前线程节点链接到head作为队列尾。

　　* 此处使用轻量级的自循环+Cas更新的方式，来处理enq函数被多线程并发执行时的问题，

　　* 想一想如果没有循环那么enq函数被多线程并发时可能带来什么问题?

　　*/

　　private Node enq(final Node node) {

　　for (;;) {

　　Node t = tail;

　　if (t == null) { // Must initialize

　　if (compareAndSetHead(new Node()))

　　tail = head;

　　} else {

　　node.prev = t;

　　if (compareAndSetTail(t, node)) {

　　t.next = node;

　　return t;

　　}

　　}

　　}

　　}

　　/**

　　* 如果节点前驱是队列头，则尝试获取锁。

　　* 此时：node就是队列首个有效节点，head在初始化时是一个无指向的Node，

　　* 而node在获取锁后通过setHead(node)被设置成为head，但同时置空了node指向的Thread和前驱节点，head仍然是个无指向的节点)

　　* 如果节点前驱不是队列头，则将前驱状态更改为SIGNAL后通过LockSupper.park()阻塞当前线程。

　　* 此时：在node之前至少有两个有效节点(node.prev和node.prev.prev)node.prev.prev此时可能已经获取锁，也可能在等待。但是node.prev

　　* 一定在等待，那么当前节点应该进入阻塞等待，而前驱节点已经处于等待状态可以被设置设置成待通知状态。

　　*/

　　final boolean acquireQueued(final Node node, int arg) {

　　boolean failed = true;

　　try {

　　boolean interrupted = false;

　　for (;;) {

　　final Node p = node.predecessor();

　　if (p == head && tryAcquire(arg)) {

　　setHead(node);

　　p.next = null; // help GC

　　failed = false;

　　return interrupted;

　　}

　　// shouldParkAfterFailedAcquire(): 保证当前节点前驱节点状态为Node.SIGNAL后

　　// parkAndCheckInterrupt(): 通过LockSupport.park() 阻塞当前线程。

　　if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())

　　interrupted = true;

　　}

　　} finally {

　　if (failed)

　　//获取成功后，

　　cancelAcquire(node);

　　}

　　}

　　/**

　　* 如果当前节点前驱节点状态为Node.SIGNAL，则返回true,否则，将前驱节点状态设置为Node.SIGNAL后

　　* 如果遇到前驱节点状态为取消的情况，则从前驱节点向前遍历，找到最后一个未被取消的节点，将当前节点连接在该节点后面。

　　*/郑州哪家医院人流好 http://www.120csfkyy.com/

　　private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

　　int ws = pred.waitStatus;

　　// 已经设置了状态，可以安全

　　if (ws == Node.SIGNAL) return true;

　　if (ws > 0) {

　　//从当前线程节点向前遍历，把当前线程节点放到队列最靠后的一个有效等待的节点。

　　do {

　　node.prev = pred = pred.prev;

　　} while (pred.waitStatus > 0);

　　pred.next = node;

　　} else {

　　compareAndSetWaitStatus(pred, ws, Node.SIGNAL);

　　}

　　return false;

　　}

　　独占锁的释放release()

　　/**

　　* 首先调tryRelease()对子类资源进行释放。

　　* 如果 head!=null 或者 head的等待状态不为零，说明仍然有后续节点在等待。此时需要唤醒后续节点。

　　*/

　　public final boolean release(int arg) {

　　if (tryRelease(arg)) {

　　Node h = head;

　　if (h != null && h.waitStatus != 0)

　　unparkSuccessor(h);

　　return true;

　　}

　　return false;

　　}

　　/**

　　* 将当前节点状态重置为零，并从队列尾部向前找到第一个有效节点，通过unpark通知该节点线程。，

　　* 为何不是从当前节点向后查找?

　　*/

　　private void unparkSuccessor(Node node) {

　　int ws = node.waitStatus;

　　if (ws < 0)

　　compareAndSetWaitStatus(node, ws, 0);

　　Node s = node.next;

　　if (s == null || s.waitStatus > 0) {

　　s = null;

　　for (Node t = tail; t != null && t != node; t = t.prev)

　　if (t.waitStatus <= 0)

　　s = t;

　　}

　　if (s != null)

　　LockSupport.unpark(s.thread);

　　}

　　共享锁的获取 acquireShare

　　有了独占模式的分析后，共享模式就简单多了。

　　/**

　　* 调用子类tryAcquireShare尝试获取锁，tryAcquireShare()函数返回值小于零时获取失败。

　　* 获取失败时，调用doAcquireShared方法处理

　　*/

　　public final void acquireShared(int arg) {

　　if (tryAcquireShared(arg) < 0)

　　doAcquireShared(arg);

　　}

　　/**

　　* 与独占模式流程相似，但是封装节点时采用的是SHARED模式。

　　*/

　　private void doAcquireShared(int arg) {

　　final Node node = addWaiter(Node.SHARED);

　　boolean failed = true;

　　try {

　　boolean interrupted = false;

　　for (;;) {

　　final Node p = node.predecessor();

　　if (p == head) {

　　int r = tryAcquireShared(arg);

　　if (r >= 0) {

　　setHeadAndPropagate(node, r);

　　p.next = null; // help GC

　　if (interrupted)

　　selfInterrupt();

　　failed = false;

　　return;

　　}

　　}

　　if (shouldParkAfterFailedAcquire(p, node) &&

　　parkAndCheckInterrupt())

　　interrupted = true;

　　}

　　} finally {

　　if (failed)

　　cancelAcquire(node);

　　}

　　}

　　/**

　　* 调用子类释放锁，然后将当前节点从队列

　　*/

　　public final boolean releaseShared(int arg) {

　　if (tryReleaseShared(arg)) {

　　doReleaseShared();

　　return true;

　　}

　　return false;

　　}

　　共享锁的释放doReleaseShared

　　/**

　　* 实际执行释放锁的操作，

　　* 由于是共享模式，在释放锁时也存在多个线程并发释放的情况，因此采用循环+CAS的机制

　　* 来使并发释放的多个线程顺序unpark队列中的后续节点。

　　*/

　　private void doReleaseShared() {

　　for (;;) {

　　Node h = head;

　　if (h != null && h != tail) {

　　int ws = h.waitStatus;

　　if (ws == Node.SIGNAL) {

　　if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

　　continue; // loop to recheck cases

　　unparkSuccessor(h);

　　}

　　else if (ws == 0 &&

　　!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

　　continue; // loop on failed CAS

　　}

　　if (h == head) // loop if head changed

　　break;

　　}

　　}

　　可中断模式 acquireSharedInterruptibly

　　中断模式也获取的也是独占锁，只是会在尝试获取锁前先检查线程的中断状态，如果线程被中断，那么会抛出InterruptedException而不会继续尝试获取锁。中断模式获取的锁也通过release()进行释放。

　　/**

　　* 在获取锁时会首先判断线程是否被中断，如果中断则直接抛出异常。

　　* 未被中断，则调用子类tryAcquire()尝试获取锁。获取失败时，通过doAcquireInterruptibly()进行处理。

　　*/

　　public final void acquireInterruptibly(int arg) throws InterruptedException {

　　if (Thread.interrupted())

　　throw new InterruptedException();

　　if (!tryAcquire(arg))

　　doAcquireInterruptibly(arg);

　　}

　　/**

　　* 与doAcquire()同样的流程，区别只在于，线程进入等待队列，而后被其他节点唤醒后，会根据线程中断状态决定后续操作：

　　* 如果线程被中断，则直接抛出InterruptedException而不会继续获取锁。

　　*/

　　private void doAcquireInterruptibly(int arg) throws InterruptedException {

　　final Node node = addWaiter(Node.EXCLUSIVE);

　　boolean failed = true;

　　try {

　　for (;;) {

　　final Node p = node.predecessor();

　　if (p == head && tryAcquire(arg)) {

　　setHead(node);

　　p.next = null; // help GC

　　failed = false;

　　return;

　　}

　　if (shouldParkAfterFailedAcquire(p, node) &&

　　parkAndCheckInterrupt())

　　throw new InterruptedException();

　　}

　　} finally {

　　if (failed)

　　cancelAcquire(node);

　　}

　　}

　　到此AQS的源码基本就完了。