ReentrantLock

目录

• 公平方式获取锁
• 非公平方式获取锁
• 释放锁

上一篇分享了AQS的基本原理：AQS（AbstractQueuedSynchronizer），在此基础上，再来看看ReentrantLock对AQS是怎么实现的，尤为是对可重入以及公平和非公平的理解

公平方式获取锁

先看看lock()方法：

final void lock() {
            acquire(1);
        }

/**
*对AQS中对应方法的重写，位于FairSync类中，锁公平获取实现方式
*/
protected final boolean tryAcquire(int acquires) {//acquires=1
            final Thread current = Thread.currentThread();//获取当前线程
            int c = getState();//获取AQS中state的值，0表示资源未被占用，既没有线程获取到锁
            if (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;
        }

大概流程：

1. 若是没有线程获取到锁：
   若是当前线程的节点在等待队列里面没有有效的前驱结点（体现公平性），就去以原子方式将state置为1，而且把持有锁的线程设置成本身，返回true（获取锁成功）；
2. 若是有线程已经获取了锁而且拿到锁的线程就是当前线程：
   AQS中的state+1，返回true（获取锁成功）；
3. 当上述两个步骤没成功执行则返回false（获取锁失败）；

主要再来看一下hasQueuedPredecessors()：

/**
*判断队列里面有没有比当前线程等待更久更先到等待队列的线程，越靠近head越优先获取锁即先到先得（公平性）
*/
public final boolean hasQueuedPredecessors() {
        Node t = tail;
        Node h = head;//当前已经得到锁的线程节点
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

非公平方式获取锁

先来看看lock()方法：

final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

和公平方式不一样的是，他会先尝试把state设置成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) {
            //该步骤相似于上面lock()方法的第一步
                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. 若是当前所没有被占用，则本身以“恶霸”的形式直接占用该锁；
2. 若是本身以前已经拿到了锁，此次重入就将state+1；

释放锁

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

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

1. 先给state-1；
2. 若是当前线程没持有锁，就抛异常；
3. 若是state在修改以后等于0，就说明锁已经被彻底释放；
4. 注意，该方法返回的是锁有没有被彻底释放。