jvm源码解析（五）synchronized和ReentrantLock

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

public void lock() {
    sync.acquire(1); // 调用AbstractQueuedSynchronizer.acquire
}

public final void acquire(int arg) {
    // 调用ReentrantLock.NonfairSync或FairSync.tryAcquire
    if (!tryAcquire(arg) &&
        // 独占锁中，获取锁失败：// 将当前线程包装进Node
            // 若当前线程是head节点的后置节点，且head状态为cancelled
            // 则尝试获取锁，若成功，则将head节点设置为null，帮助原来的head节点gc（此时等待队列没有Node了）
            // 否则尝试挂起当前线程
                // 如果前驱节点的状态为Signal，则挂起当前线程
                // 如果前驱节点被cancelled，则尝试找到非cancelled状态的节点，并将他的next设置成当前节点
                // 否则（前驱节点的waitStatus<0），则将前驱节点的状态设置成0
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 调用Thread.currentThread().interrupt();停止线程
        selfInterrupt(); 
}

// 保护被注解的方法，通过添加一些额外的空间，防止在多线程运行的时候出现栈溢出
@ReservedStackAccess
final boolean nonfairTryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取当前锁状态
    int c = getState();
    // 没有线程持有锁
    if (c == 0) {
    // cas尝试将锁状态换成1
        if (compareAndSetState(0, acquires)) {
         // 如果cas成功，则将当前线程设置成当前锁的持有线程
            setExclusiveOwnerThread(current);
            return true; // 返回上锁成功
        }
    }
    // 如果有线程持有锁，且持有线程是当前线程
    else if (current == getExclusiveOwnerThread()) {
        // 锁状态 + 1 可重入锁--可重入的含义
        int nextc = c + acquires;
        // 重入次数溢出，超过Integer.MAX_VALUE导致变成负数
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 设置锁状态
        setState(nextc);
        // 返回获取锁成功
        return true;
    }
    // 已经有线程获取锁，且非当前线程，返回获取锁失败
    return false;
}

@ReservedStackAccess
protected final boolean tryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取当前锁状态
    int c = getState();
    // 没有线程持有锁
    if (c == 0) {
        // 等待队列没有待唤醒且仍存活的线程
        if (!hasQueuedPredecessors() &&
       // 尝试获取当前锁 
            compareAndSetState(0, acquires)) {
            // 获取成功，将当前线程设置为当前锁所有线程
            setExclusiveOwnerThread(current);
            // 返回获取锁成功
            return true;
        }
    }
    // 如果有线程持有锁，且持有线程是当前线程
    else if (current == getExclusiveOwnerThread()) {
        // 锁状态 + 1
        int nextc = c + acquires;
        // 重入次数溢出，超过Integer.MAX_VALUE导致变成负数
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 设置锁状态
        setState(nextc);
        // 返回获取成功
        return true;
    }
    // 返回获取失败
    return false;
}

public void unlock() {
    sync.release(1); // 调用AbstractQueuedSynchronizer.release
}

public final boolean release(int arg) {
    // 调用ReentrantLock.Sync.tryRelease(1)
    if (tryRelease(arg)) {
        // 获取等待队列的head
        Node h = head;
        // 如果等待队列有node，且线程并不是处于初始状态
        if (h != null && h.waitStatus != 0)
            //调用AbstractQueuedSynchronizer.unparkSuccessor，尝试唤醒等待队列头部线程
            unparkSuccessor(h);
        // 返回解锁成功
        return true;
    }
    // 返回失败
    return false;
}

@ReservedStackAccess
protected final boolean tryRelease(int releases) {
    // 持有锁状态 - 1(放一次锁，但不一定保证是把锁直接放掉，有可能重入了)
    int c = getState() - releases;
    // 如果当前线程不是锁持有者，则报错
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 设置返回的状态，标识着锁是否完全释放
    boolean free = false;
    // 锁状态为0（完全不持有）
    if (c == 0) {
        // 返回值设置为已释放锁，且锁持有线程设置为null
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 设置锁状态
    setState(c);
    // 返回锁是否已经没有线程持有
    return free;
}

private void unparkSuccessor(Node node) {
    // 获取等待状态
    int ws = node.waitStatus;
    // 等待状态小于0，则设置为初始状态
    if (ws < 0)
        node.compareAndSetWaitStatus(ws, 0);
    // 获取下一个node（队列中下一个线程）
    Node s = node.next;
    // node为空或者状态为cancelled
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 循环找到下一条能执行的线程
        for (Node p = tail; p != node && p != null; p = p.prev)
            if (p.waitStatus <= 0)
                s = p;
    }
    // 如果有下一个能执行的线程
    if (s != null)
        // 给node增加调用凭证
        // 调用线程的时候会判断，如果凭证不为0则挂起
        // 凭证只能有1个，所以unpark多次也是一样的效果
        LockSupport.unpark(s.thread);
}