Java ReentrantLock中tryLock与lock的区别（非公平锁与公平锁）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

设置同步状态，利用CAS操作。

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

protected final boolean compareAndSetState(int expect, int update)

进入 tryLock ，实际上是非公平锁的实现（ 非公平锁：不能保证正在排队的线程能拿到锁，因为可能被新来的线程抢走 ）

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;

}

进入 lock ，实际上是公平锁的实现（ 公平锁：老的线程在排队，新来的线程也一样要排队，不能抢占 ）

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;

}