ReentrantLock

ReentrantLock是一个可重入的互斥锁，ReentrantLock由最近成功获取锁，还没有释放的线程所拥有，当锁被另一个线程拥有时，调用lock的线程可以成功获取锁

。如果锁已经被当前线程拥有，当前线程会立即返回。此类的构造方法提供一个可选的公平参数。ReentrantLock顾名思义就是锁可以重入，一个线程持有锁，state=1,如果它再次调用lock方法，那么他将继续拥有这把锁，state=2.当前可重入锁要完全释放

，调用了多少次lock方法，还得调用等量的unlock方法来完全释放锁。

 

reentrantLock根据构造参数的 boolean参数来决定new公平锁or非公平锁,默认为非公平锁。

所谓公平就是严格按照FIFO(先入先出)顺序获取锁，非公平安全由程序员自己设计，比如可以按优先级，也可以按运行次数等规则来选择

 public ReentrantLock(boolean fair) {

        sync = fair ? new FairSync() : new NonfairSync();

    }

 

获取锁的过程：

1. 公平锁   

    首先判断锁有没有被持有，如果被持有，就判断持有锁的线程是不是当前线程，如果不是就啥也不做，返回获取失败，如果是就增加重入数，返回成功获取；

    如果锁没有被任何线程持有（c==0），首先判断当前结点前面是否还有线程在排除等待锁，如果有，直接返回获取失败，否则将锁持有数设为acquires，一般为1，

然后设置锁的拥有者为当前线程，成功获取。

protected final boolean tryAcquire(int acquires) {  
    final Thread current = Thread.currentThread();  
    int c = getState();   // 获取当前锁状态
    if (c == 0) {  // c == 0 意味着没有被任何线程持有
         // 尝试加锁操作
        if (!hasQueuedPredecessors() &&  
            compareAndSetState(0, acquires)) {  
            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;  
}  

2. 非公平锁

唯一不同的是在知道锁持有数为0时，直接将当前线程设置为锁的持有者，这一点和公平版本的tryAcquire是有区别的，也就是说非公平机制采用的是抢占式模型。

final boolean nonfairTryAcquire(int acquires) {  
    final Thread current = Thread.currentThread();  
    int c = getState();  
    if (c == 0) {  
        if (compareAndSetState(0, acquires)) {   // 直接抢占加锁 
            setExclusiveOwnerThread(current);   // 将线程所有者设置为自己
            return true;  
        }  
    }  
    else if (current == getExclusiveOwnerThread()) {  
        int nextc = c + acquires;  
        if (nextc < 0) // overflow  
            throw new Error("Maximum lock count exceeded");  
        setState(nextc);  
        return true;  
    }  
    return false;  
}  

释放过程 : 

  公平锁和非公平锁释放是一致的

1、首先判断当前线程是不是拥有锁的线程，如果不是，抛出IllegalMonitorStateException异常，这个异常表明表明某一线程已经试图等待对象的监视器，
    或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程；
2、判断释放之后的锁持有数c，如果c!=0，先设置state为该值，然后返回false表示没有被完全释放。如果c==0，表示锁被完全释放，当前线程释放对锁的拥有，返回true,
    表示已完全释放。
可以使用isHeldByCurrentThread() 和 getHoldCount()方法来检查当前线程是否拥有该锁

protected final boolean tryRelease(int releases) {  
    int c = getState() - releases;  // 做减法 释放后锁的计数
    if (Thread.currentThread() != getExclusiveOwnerThread())  
        throw new IllegalMonitorStateException();  
    boolean free = false;  
    if (c == 0) {   // c == 0 代表锁被完全释放
        free = true;  
        setExclusiveOwnerThread(null);   // 清除线程所有者
    }   
    setState(c);  
    return free;  
}  

Reentrantlock加锁的过程:

 final void lock() {
     if (compareAndSetState(0, 1)) // 尝试去cas加锁
        setExclusiveOwnerThread(Thread.currentThread()); 
     else
        acquire(1);
 }

  其中lock方法为 NofairSync类的方法。 compareAndSetState为aqs类(abstractQueuedSynchronized)的方法。 setExclusiveOwnerThread方法为AbstractOwnableSynchronizer类的方法

  会尝试获取锁，如果获取不到则加入到等待队列里。 等待队列是由 head <-> node <-> node 模式，保证head在轮训尝试不断的获取锁，当head获取锁之后会唤醒后面的第一个节点，以此类推

private volatile int state; // 等于0则说明没有锁,>0都代表有锁

public final void acquire(int arg) {
     if (!tryAcquire(arg) &&  acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//
       selfInterrupt();
}

protected final boolean tryAcquire(int acquires) { // 尝试去获取锁
            return nonfairTryAcquire(acquires);
}

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode); // Node.EXCLUSIVE,所以NODE为独占模式,  在将这个节点插入到等待队列的尾部(如果队列没有节点则新建)
        Node pred = tail;
        if (pred != null) {
            node.prev = pred; // 将当前节点的前驱设置为尾部节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;// 更新尾部节点
                return node;
            }
        }
        enq(node);// 如果tail为空则代表没有队列,则新建
        return node;
} 

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;
                }
            }
        }
}

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor(); // 获取当前节点的前一个node
                if (p == head && tryAcquire(arg)) {// 如果前面的节点是正在锁定的节点,则再次尝试获取锁
                    setHead(node);
                    p.next = null; // 清理刚才上锁的node,便于GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) && 
                    parkAndCheckInterrupt())  // 如果上述获取锁失败，则阻塞当前线程,并唤醒等待线程
                    interrupted = true;
            }
        } finally {
            if (failed) // 如果获取锁失败,并且唤醒下一个节点也失败
                cancelAcquire(node); // 取消node
        }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;// 前一个节点的等待状态
        if (ws == Node.SIGNAL) // SIGNAL == -1 表示这个node的下一个node被阻塞了,如果完事需要通知下一个节点,即 需要唤醒下一个节点
            return true;
        if (ws > 0) { // 继续向前走,知道找到=0的,即代表锁可以被释放的节点
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;//返回等待队列的第一个
        } else {
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false; // 其余状态都返回false
}

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this); // 调用方法阻塞线程
        return Thread.interrupted(); // 返回线程的上次的中断状态，并清除中断状态
}

public static void park(Object blocker) {// 阻塞线程
    Thread t = Thread.currentThread(); 
    setBlocker(t, blocker);
    unsafe.park(false, 0L);
    setBlocker(t, null);
}

// 这个方法有点没读懂
private void cancelAcquire(Node node) {
        if (node == null)
            return;
        node.thread = null;
        Node pred = node.prev; // 获取上一个node
        while (pred.waitStatus > 0) // 找到第一个等待node
            node.prev = pred = pred.prev;
        Node predNext = pred.next;
        node.waitStatus = Node.CANCELLED; // 准备取消节点
        if (node == tail && compareAndSetTail(node, pred)) { // 如果节点是尾部节点,则换尾
            compareAndSetNext(pred, predNext, null);
        } else {
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
这里如果不调用unparkSuccessor, 若在interrupted之后，执行到上面一句将waitStatus置CANCELLED之前，锁被释放，该线程被唤醒，则释放锁线程的unparkSuccessor不能起到预期作用，所以这里需要调用unparkSuccessor.即使此时持有锁的线程没有释放锁也不会有严重后果，被unpark的线程在获取锁失败后会继续park
                unparkSuccessor(node);
            }
            node.next = node; // help GC
        }
}

// TODO