并发编程AQS--------ReentrantLock

同步框架AbstractQueuedSynchronizer

Java并发编程核心在于java.concurrent.util包 而juc当中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS，AQS定义了一套多线程访问共享资源的同步器框架，是一个依赖状态(state)的同步器。

AQS具备特性 阻塞等待队列、 共享/独占、 公平/非公平、 可重入(同一把锁同一个线程可重复拿)、 允许中断。

一般通过定义内部类Sync继承AQS 将同步器所有调用都映射到Sync对应的方法

state 记录加锁的次数，体现锁的可重入性；访问方式哟有三种   getState()、setState()、compareAndSetState()

exclusiveOwnerThread 体现独占线程的特性，记录的是当前独占的线程。

AQS定义两种资源共享方式 Exclusive-独占，只有一个线程能执行，如ReentrantLock Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch

Node,阻塞队列的体现：等待队列，条件队列。各种属性定义如下

static final class Node {
    /**
     * 标记节点未共享模式
     * */
    static final Node SHARED = new Node();
    /**
     *  标记节点为独占模式
     */
    static final Node EXCLUSIVE = null;

    /**
     * 在同步队列中等待的线程等待超时或者被中断，需要从同步队列中取消等待
     * */
    static final int CANCELLED =  1;
    /**
     *  后继节点的线程处于等待状态，而当前的节点如果释放了同步状态或者被取消，
     *  将会通知后继节点，使后继节点的线程得以运行。
     */
    static final int SIGNAL    = -1;
    /**
     *  节点在等待队列中，节点的线程等待在Condition上，当其他线程对Condition调用了signal()方法后，
     *  该节点会从等待队列中转移到同步队列中，加入到同步状态的获取中
     */
    static final int CONDITION = -2;
    /**
     * 表示下一次共享式同步状态获取将会被无条件地传播下去
     */
    static final int PROPAGATE = -3;

    /**
     * 标记当前节点的信号量状态 (1,0,-1,-2,-3)5种状态
     * 使用CAS更改状态，volatile保证线程可见性，高并发场景下，
     * 即被一个线程修改后，状态会立马让其他线程可见。
     */
    volatile int waitStatus;

    /**
     * 前驱节点，当前节点加入到同步队列中被设置
     */
    volatile Node prev;

    /**
     * 后继节点
     */
    volatile Node next;

    /**
     * 节点同步状态的线程
     */
    volatile Thread thread;

    /**
     * 等待队列中的后继节点，如果当前节点是共享的，那么这个字段是一个SHARED常量，
     * 也就是说节点类型(独占和共享)和等待队列中的后继节点共用同一个字段。
     */
    Node nextWaiter;

如果节点存在条件队列中，只能是独占模式不能是共享方式。

等待队列其实是一个双向链表结构，每个节点记录的有前驱节点和后驱节点。

两种队列都是基于Node节点构建的，每个节点的Node都会有信号量，也就是属性waitSate

条件队列其实是单向链表；

ReentrantLock是一把可重入的，独占的显示锁，构造的时候可以传入一个布尔值来决定是不是公平/非公平锁

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

true为公平锁，false为非公平锁

如何理解公平锁和非公平锁

假如线程A结束后唤醒了线程B，此时新来一个线程C，如果线程C能和线程B抢锁，那么这个是非公平锁，如果新来的线程C只能怪怪去排队，那么就是公平锁。

加锁过程，每加一次锁state都会加1，释放一次锁，state都会减1，exclusiveOwnerThread记录的当前持有锁的线程。

分析一下取锁的源码

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {--------表示没有线程占用锁，可以取拿锁
                if (!hasQueuedPredecessors() &&  -------------判断队列里面没有线程在等待才能去抢锁，这就是公平的体现
                    compareAndSetState(0, acquires)) {  -------cas算法原子操作改变state值，state值又被volitale修饰，保证并发下修改state的安全性。
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

线程被阻塞之后会被放在等待队列里面，即我们那个双链表结够，注意我们这个双链表的head的属性thread是null，也就是说head不放任何线程信息，仅仅是做head标记位使用。

ReentrantLock加锁的过程

 public final void acquire(int arg) {
        // 尝试获取锁，获取锁失败，addWaiter方法加入到CLH等待队列，Node.EXCLUSIVE表示以独占的方式入队；
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

private Node addWaiter(Node mode) {
    // 1. 将当前线程构建成Node类型
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    // 2. 1当前尾节点是否为null？
    if (pred != null) {
        // 2.2 将当前节点尾插入的方式
        node.prev = pred;
        // 2.3 CAS将节点插入同步队列的尾部
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

注意这里的for(;;)循环；

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;
            //set尾部节点
            if (compareAndSetTail(t, node)) {//当前节点置为尾部
                t.next = node; //前驱节点的next指针指向当前节点
                return t;
            }
        }
    }
}

注意AQS里面的线程唤醒不会唤醒所有的等待线程，而回唤醒头节点的next线程（head头节点不放线程），做到顺序唤醒，而object的notify方法和notifyall方法会唤醒所以有的线程。无序。

线程的阻塞和唤醒用的是魔术类Unsafe里面的park（）和unpark（）方法，底层是调用Pthead_mutex_lock指令库方法。

代码;

 public final void acquire(int arg) {
        // 尝试获取锁，获取锁失败，addWaiter方法加入到CLH等待队列，Node.EXCLUSIVE表示以独占的方式入队；
        // acquireQueued对入队的线程进行阻塞
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

/**
 * 已经在队列当中的Thread节点，准备阻塞等待获取锁
 */
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)) {//如果前驱结点是头结点，才tryAcquire，其他结点是没有机会tryAcquire的。
                setHead(node);//获取同步状态成功，将当前结点设置为头结点。
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            /**
             * 如果前驱节点不是Head，通过shouldParkAfterFailedAcquire判断是否应该阻塞
             * 前驱节点信号量为-1，当前线程可以安全被parkAndCheckInterrupt用来阻塞线程
             */
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

public class LockSupport {
    private LockSupport() {} // Cannot be instantiated.

    private static void setBlocker(Thread t, Object arg) {  //unsafe魔术类阻塞线程。
        // Even though volatile, hotspot doesn't need a write barrier here.
        UNSAFE.putObject(t, parkBlockerOffset, arg);
    }