// CAS操作：如果当前状态值等于期望值，则自动将同步状态设置为给定的更新值

protected final boolean compareAndSetState(int expect, int update)

public boolean tryLock() {

    return sync.nonfairTryAcquire(1);

}

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;

}

public void lock() {

    sync.lock();

}

final void lock() {

    acquire(1);

}

 public final void acquire(int arg) {

    if (!tryAcquire(arg) &&

        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))    // 如果获取不到锁，就放进等待队列（addWaiter），然后阻塞直到成功获取到锁

        selfInterrupt();

}

protected final boolean tryAcquire(int acquires) {

    final Thread current = Thread.currentThread();

    int c = getState();

    if (c == 0) {

        // 唯一与非公平锁不同的是：先判断等待队列是否有等待的线程，没有的话再更改同步状态。否则返回false。

        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;

}