ReentrantLock加锁与解锁及相关API的详细流程

下面是ReentrantLock非公平锁加锁流程：

final void lock() {
	//调用CAS尝试获取锁
    if (compareAndSetState(0, 1))
    	//尝试成功则修改当前拥有锁的线程是自己
        setExclusiveOwnerThread(Thread.currentThread());
    else
    	//获取失败
        acquire(1);
}

public final void acquire(int arg) {
	//tryAcquire：尝试获取锁，加取反则表示获取失败后执行&&后面的方法
	//addWaiter：将当前线程封装为Node后添加到同步队列尾部
	//acquireQueued：线程入队后再次尝试获取锁或者阻塞
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
	//非公平的尝试获取锁
    return nonfairTryAcquire(acquires);
}

final boolean nonfairTryAcquire(int acquires) {
	//获取当前线程
    final Thread current = Thread.currentThread();
    //获取当前锁状态
    int c = getState();
    //如果锁空闲
    if (c == 0) {
    	//调用CAS尝试获取锁
        if (compareAndSetState(0, acquires)) {
        	//尝试成功则修改当前拥有锁的线程是自己
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果锁仍被持有而且持有锁的线程是自己
    //这里体现了ReentrantLock的可重入性
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        //锁状态state不能为负值
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        //修改state，不使用CAS是因为此时不可能有其他线程可以修改state
        setState(nextc);
        return true;
    }
    //获取锁失败
    return false;
}

private Node addWaiter(Node mode) {
	//给当前线程新建Node结点，mode表示是排它锁还是共享锁
    Node node = new Node(Thread.currentThread(), mode);
    //pred指向尾结点
    Node pred = tail;
    //如果尾结点不为空，意味着队列已经被初始化
    //但不一定有线程在队列中等待，因为队列的头结点对应的线程永远是null
    if (pred != null) {
    	//让新建的结点的前驱结点指向尾结点
        node.prev = pred;
        //调用CAS尝试修改新建结点为尾结点
        if (compareAndSetTail(pred, node)) {
        	//尝试成功则设置原来的尾结点的后继结点指向新建结点
        	//如果修改失败则意味着此时有其他线程加入队列且修改了尾结点
            pred.next = node;
            return node;
        }
    }
    //如果队列还没有被初始化或者上面的CAS失败则调用enq
    enq(node);
    return node;
}

private Node enq(final Node node) {
	//死循环即自旋，保证了所有进入此方法的结点都能被正确的添加到队列中
    for (;;) {
    	//t指向尾结点
        Node t = tail;
        //如果尾结点为空则意味着队列还没有被初始化
        if (t == null) { // Must initialize
        	//调用CAS尝试新建线程为null的结点作为头结点
            if (compareAndSetHead(new Node()))
            	//尝试成功则将尾结点也指向头结点，失败则进入下一次自旋
                tail = head;
        } else {	//如果队列已经被初始化
        	//让新建结点的前驱结点指向尾结点
            node.prev = t;
            //调用CAS尝试修改新建结点为尾结点
            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 (;;) {
        	//p指向新建结点的前驱结点
            final Node p = node.predecessor();
            //如果p是头结点即node是队列中第一个等待的线程
            //则再次调用tryAcquire尝试获取锁
            if (p == head && tryAcquire(arg)) {
            	//获取成功则设置当前结点为头结点（对应线程永远为null）
                setHead(node);
                //设置原来的头结点的后继节点为null，那么该结点不再
                //被任何地方引用也不再引用任何其他对象，由GC负责回收
                p.next = null; // help GC
                //获取锁成功标识
                failed = false;
                //这里返回false则表示线程没有被申请中断
                return interrupted;
            }
            //shouldParkAfterFailedAcquire：判断当前线程是否应该被挂起
            //parkAndCheckInterrupt：挂起线程，清空线程的中断标识并返回
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	//获取node的前驱结点pred的状态标识
	//SIGNAL值为-1，标识该结点的后继结点需要被唤醒
	//CANCELLED值为1，标识该结点被终止，不再参与锁竞争
    int ws = pred.waitStatus;
    //如果node的前驱结点pred的状态标识为SIGNAL
    if (ws == Node.SIGNAL)
    	//可以被挂起
        return true;
    //如果node的前驱结点pred的状态标识为CANCELLED
    if (ws > 0) {
    	//队列从后往前清除状态标识为CANCELLED的结点
        do {
        	//这是第一个可能删除结点的地方
        	//从后往前直到第一个SIGNAL结点间的所有CANCELLED结点被删除
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        //设置前驱结点pred的后继结点为当前结点node
        pred.next = node;
    } else {
        //若前驱结点pred的状态标识为初始状态则修改为SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    //暂时不能被挂起
    return false;
}

private final boolean parkAndCheckInterrupt() {
	//系统调用挂起线程，线程在这里真正被阻塞
	//从这里被唤醒有两种可能：一是unpark()，二是interrupt()
    LockSupport.park(this);
    //清除线程中断标识并返回
    return Thread.interrupted();
}

下面是ReentrantLock解锁流程：

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
	//尝试释放当前锁
    if (tryRelease(arg)) {
    	//h指向头结点
        Node h = head;
        //如果队列非空且头结点的状态标识为SIGNAL
        if (h != null && h.waitStatus != 0)
        	//唤醒头结点的后继结点
            unparkSuccessor(h);
        //释放成功
        return true;
    }
    //释放失败，意味着该锁被重入了，释放次数<加锁次数
    return false;
}

protected final boolean tryRelease(int releases) {
	//获取锁状态state并减去要释放的数量即1
    int c = getState() - releases;
    //如果释放锁的线程不是拥有锁的线程则抛异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //如果释放一次锁后锁状态变为空闲
    if (c == 0) {
        free = true;
        //修改当前拥有锁的线程为null
        setExclusiveOwnerThread(null);
    }
    //修改锁状态为0即空闲
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
	//获取当前结点的状态标识，此时可能为SIGNAL或者CANCELLED
	//如果为CANCELLED意味着node已经被唤醒但发现自己被中断需要继续往后唤醒新的结点
    int ws = node.waitStatus;
    //如果当前结点状态标识为SIGNAL
    if (ws < 0)
    	//调用CAS修改当前结点状态标识为0即初始状态
        compareAndSetWaitStatus(node, ws, 0);
    //s指向当前结点的后继结点
    Node s = node.next;
    //如果队列中没有等待的线程或者s的状态标识为CANCELLED
    if (s == null || s.waitStatus > 0) {
        s = null;
        //队列从后往前找到最后一个（也就是从前往后第一个）
        //状态标识不是CANCELLED的结点，且不能是当前结点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    //如果队列中有等待被唤醒的线程
    if (s != null)
    	//系统调用唤醒第一个等待的线程
    	//被阻塞的线程会在parkAndCheckInterrupt()中继续向下执行
        LockSupport.unpark(s.thread);
}

下面是ReentrantLock可中断获取锁的流程：

//当某个线程调用该方法去获取锁却被阻塞时，可以响应中断标识
//而传统的synchronized无法实现让因为锁竞争被阻塞的线程去响应中断标识
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    //如果线程中断标识为true，则清空标识并返回中断异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //如果尝试获取锁失败
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

private void doAcquireInterruptibly(int arg)
    throws InterruptedException {
    //给当前线程新建结点并入队
    final Node node = addWaiter(Node.EXCLUSIVE);
    //获取锁失败的标识
    boolean failed = true;
    try {
    	//自旋的大部分操作与正常lock一致
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return;
            }
            //与正常lock的流程在这里仅修改被中断标识不同
            //抛出中断异常从而实现可中断的获取锁
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
    	//获取锁失败，意味着线程被唤醒后发现自己中断标识为true
        if (failed)
        	//让自己不再参与锁竞争
            cancelAcquire(node);
    }
}

private void cancelAcquire(Node node) {
    //保险起见？
    if (node == null)
        return;
	//修改当前结点对应线程为null
    node.thread = null;

    //跳过状态标识为CANCELLED的前驱结点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    //predNext指向前驱结点的后继结点，给CAS作为旧值使用
    Node predNext = pred.next;

    //修改当前结点的状态标识为CANCELLED
    node.waitStatus = Node.CANCELLED;

    //如果当前结点是尾结点，则删除自身
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
        //如果前驱结点不是头结点且对应线程不为null，而且状态标识为SIGNAL
        //或者状态标识为CONDITION则调用CAS设置为SIGNAL且修改成功
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            //如果后继结点不为空且状态标识不为CANCELLED
            if (next != null && next.waitStatus <= 0)
            	//CAS在队列中删除自身节点
            	//这是第二个可能删除结点的地方，且只删除自身
                compareAndSetNext(pred, predNext, next);
        } else {
        	//如果我是第一个等待的结点那么还需向后唤醒被阻塞的线程
        	//这里说明了一个点：当一个线程被unpark()时不一定是锁资源被释放
        	//也可能是队列第一个等待的线程响应了中断或者获取锁超时
            unparkSuccessor(node);
        }
		//删除自身指向其他其他结点的引用
        node.next = node; // help GC
    }
}

下面是ReentrantLock定时获取锁的流程：

//这里调用的nonfairTryAcquire只会尝试获取一次直接返回
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}
//定时获取锁
public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

//定时获取锁也可以响应中断
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //尝试获取一次锁，失败则调用doAcquireNanos
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    //定时必须大于0（即使小于0也可能在上面的方法中获取到锁...）
    if (nanosTimeout <= 0L)
        return false;
    //记录终止时间
    final long deadline = System.nanoTime() + nanosTimeout;
    //给当前线程新建Node结点并入队
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
        	//p指向当前结点的前驱结点
            final Node p = node.predecessor();
            //如果前驱结点是头结点则有机会再尝试获取锁
            if (p == head && tryAcquire(arg)) {
            	//获取成功则修改头结点
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            //计算还剩多少时间可以尝试
            nanosTimeout = deadline - System.nanoTime();
            //小于等于0则表示到时间了但仍未获取到锁
            if (nanosTimeout <= 0L)
                return false;
            //如果可以挂起且剩余时间大于最小阈值
            //最小阈值可以避免让系统挂起后马上又要超时唤醒
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                //在剩余时间内持续挂起，在这里被唤醒有三种情况：
                //1.unpark()唤醒，此时锁变为空闲进入下一次自旋
                //2.interrupt()唤醒，表示被中断，抛异常
                //3.挂起时间结束，则进入下一次自旋
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
    	//如果获取锁失败（超时或被中断），则清除自身
        if (failed)
            cancelAcquire(node);
    }
}

公平锁和非公平锁不一样的地方（仅加锁的时候有一点区别）：

//非公平锁的lock()方法
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
//公平锁的lock()方法，可以看到非公平锁在这里多尝试了一次获取锁
final void lock() {
    acquire(1);
}

//非公平锁的tryAcquire()方法
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
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;
}
//公平锁的tryAcquire()方法
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
    	//区别在这里，当线程尝试直接获取锁时如果锁是空闲的
    	//那么还要调用hasQueuedPredecessors判断自己是否需要排队
        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;
}

//注意上面调用这个方法的前面有取反运算符
public final boolean hasQueuedPredecessors() {
    //获取头结点和尾结点
    Node t = tail;
    Node h = head;
    Node s;
    //如果h==t意味着队列还未初始化或者队列中没有线程等待，直接返回false
    //如果队列中头结点的后继结点不为空且对应着另外的线程，那么我就需要排队
    //如果s的状态标识为CANCELLED也需要往后排队，当调用cancelAcquire(s)时会向后传播从而唤醒自己
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

值得注意的点：不管是哪种方式去获取锁，底层需要阻塞线程时使用的都是park()方法或者parkNanos()方法，它们都是会响应中断的。这就意味着即使是普通的lock()方法获取锁，当线程A因为拿不到锁被阻塞时，此时线程B调用A.interrupt()那么A也会被唤醒，但是并没有进行中断处理，而是清除A的中断标识并记录然后继续让A去尝试并争抢锁，当A拿到锁返回时再去调用A.interrupt()。而可中断获取锁和定时获取锁在这里都是抛出了中断异常，故它俩都属于可中断获取锁的类型。