面试官: 有了解过ReentrantLock的底层实现吗？说说看

小鱼儿 2023-09-29 16:30 12阅读 0赞

### 前言 ###

目前正在出一个`Java多线程专题`长期系列教程，从入门到进阶含`源码解读`, 篇幅会较多, 喜欢的话，给个关注❤️ ~

### 源码剖析 ###

上节带大家学习了它的基本使用，我们可以了解到它是一个`可重入锁`,下面我们就一起看一下它的底层实现~

#### 构造函数 ####

我们在使用的时候，都是先`new`它，所以我们先看下它的`构造函数`,它主要有两个:

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

从字面上看，它们之间的不同点在于`fair`,翻译过来就是公平的意思,大体可以猜到它是用来构建`公平锁和非公平锁`,在继续往下看源码之前，先给大家科普一下这两种锁。

#### 公平锁 & 非公平锁 ####

*  `公平锁` 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。(例如银行办业务取号)

这种锁的优点很明显，每个线程都能够获取资源，缺点也很明显，如果某个线程阻塞了，其它线程也会阻塞，然而cpu唤醒开销很大，之前也给大家讲过

*  `非公平锁` 多个线程都去尝试获取锁，获取不到就进入等待队列，cpu也不用去唤醒

优缺点正好和上边相反,优点减少开销，缺点也很明显，可能会导致一直获取不到锁或长时间获取不到锁

好，有了基本概念之后，我们继续往下看

#### NonfairSync ####

首先，我们看下非公平锁,默认情况下，我们申请的都是非公平锁，也就是`new ReentrantLock()`,我们接着看源码

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
    
        /**
            * Performs lock.  Try immediate barge, backing up to normal
            * acquire on failure.
            */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
    
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

它继承了`Sync`,Sync是一个内容静态抽象类:

abstract static class Sync extends AbstractQueuedSynchronizer {...}

分为公平和非公平，使用`AQS`状态来表示持锁的次数,在构造函数初始化的时候都有`sync = ...`,我们接着看`NonfairSync`。在使用的时候，我们调用了`lock.lock()`方法,它是`ReentrantLock`的一个实例方法

// 获取锁
     public void lock() {
            sync.lock();
        }

实际上内部还是调了`sync`的内部方法,因为我们申请的是`非公平锁`,所以我们看`NonfairSync`下的lock实现:

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

`compareAndSetState`这个方法,是`AQS`的内部方法,意思是如果当前状态值等于预期值，则自动将同步状态设置为给定的更新值。此操作具有volatile读写的内存语义。

protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

可以看到执行`lock`方法,会通过`AQS`机制计数，`setExclusiveOwnerThread`设置线程独占访问权限,它是`AbstractOwnableSynchronizer`的一个内部方法，子类通过使用它来管理线程独占

public abstract class AbstractQueuedSynchronizer
        extends AbstractOwnableSynchronizer
        implements java.io.Serializable {}

可以看到它是继承了`AbstractOwnableSynchronizer`。下面接着看，我们说如果实际值等于期望值会执行上边的方法，不期望的时候会执行`acquire(1)`

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

这个方法以独占模式获取，忽略中断，它会尝试调用`tryAcquire`,成功会返回，不成功进入线程排队,可以重复阻塞和解除阻塞。看下`AQS` 内部的这个方法

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

我们可以看到实现肯定不在这，它的具体实现在`NonfairSync`

protected final boolean tryAcquire(int acquires) {
                return nonfairTryAcquire(acquires);
            }

可以看到它调用了，`nonfairTryAcquire`方法,这个方法是不公平的`tryLock`,具体实现在`Sync内部`，这里我们要重点关注一下

final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
    
        // 返回同步状态值，它是AQS内部的一个方法 
        //  private volatile int state;
        // protected final int getState() {
        //     return state;
        // }
        int c = getState();
        if (c == 0) {
            // 为0就比较一下，如果与期望值相同就设置为独占线程，说明锁已经拿到了
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 否则 判断如果当前线程已经是被设置独占线程了
        else if (current == getExclusiveOwnerThread()) {
    
            // 设置当前线程状态值 + 1 并返回成功
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        // 否则返回失败 没拿到锁
        return false;
    }

好，我们再回过头看下 `acquire`

public final void acquire(int arg) {
             // 如果当前线程没有获取到锁 并且 在队列中的线程尝试不断拿锁如果被打断了会返回true, 就会调用 selfInterrupt   
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

`selfInterrupt`很好理解,线程中断

static void selfInterrupt() {
            Thread.currentThread().interrupt();
        }

其实我们关注的重点是这个方法`acquireQueued`，首先关注一下入参,它内部传入了一个`addWaiter`,最后它回`NODE`节点

private Node addWaiter(Node mode) {
           // mode 没啥好说的就是一个标记，用于标记独占模式   static final Node EXCLUSIVE = null;
            Node node = new Node(Thread.currentThread(), mode);
            // Try the fast path of enq; backup to full enq on failure
            Node pred = tail;
            if (pred != null) {
                node.prev = pred;
                if (compareAndSetTail(pred, node)) {
                    pred.next = node;
                    return node;
                }
            }
            enq(node);
            return node;
        }

我们可以大体从猜到，`Node`是一个等待队列的节点类,是一个链表结构，之前我们讲`FutureTask`源码的时候也遇到过这种结构，它通常用于`自旋锁`,在这个地方，它是用于`阻塞同步器`

+------+  prev +-----+       +-----+
    head |      | <---- |     | <---- |     |  tail
         +------+       +-----+       +-----+

好，下面我们关注一下 `acquireQueued`

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            // 默认是 false
            boolean interrupted = false;
            // 进入阻塞循环遍历 线程队列
            for (;;) {
                // 返回前一个节点
                final Node p = node.predecessor();
    
                // 判断如果前一个节点是头部节点，并且拿到锁了，就会设置当前节点为头部节点
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    // 这里可以看到注释 help gc ,
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 检查并更新未能获取的节点的状态。如果线程应该阻塞，则返回 true 并且线程中断了
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            // 如果失败  取消正在尝试获取的节点
            if (failed)
                cancelAcquire(node);
        }
    }

从上面的源码来看，在体会一下上面讲的`非公平锁`的概念，是不是更好理解一些,然后就是释放锁`unlock`,这个方法我们可以看到是`ReentrantLock`下的一个实例方法，所以公平锁的释放锁也是调的这个方法,其实最终可以猜到调用的还是`sync`的方法

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

`Sync`继承`AQS`,release是`AQS`的内部方法

public final boolean release(int arg) {
           // 尝试释放锁  tryRelease 在Sync内部
            if (tryRelease(arg)) {
                Node h = head;
                // 如果节点存在 并且状态值不为0
                if (h != null && h.waitStatus != 0)
                    // 唤醒下个节点
                    unparkSuccessor(h);
                return true;
            }
            return false;
        }

private void unparkSuccessor(Node node) {
         
            int ws = node.waitStatus;
            if (ws < 0)
                compareAndSetWaitStatus(node, ws, 0);
    
            Node s = node.next;
            if (s == null || s.waitStatus > 0) {
                s = null;
                for (Node t = tail; t != null && t != node; t = t.prev)
                    if (t.waitStatus <= 0)
                        s = t;
            }
            if (s != null)
                // 可以看到调用了 LockSupport来唤醒
                LockSupport.unpark(s.thread);
        }

我们再看下`tryRelease`, 同样这个实现在`Sync`内

protected final boolean tryRelease(int releases) {
                // 同样释放锁的时候 依然使用 AQS计数
                int c = getState() - releases;
                // 判断当前线程是否是独占线程，不是抛出异常
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                // 如果是0 表示是释放成功
                if (c == 0) {
                    free = true;
                    // 并且把独占线程设为null
                    setExclusiveOwnerThread(null);
                }
                // 更新状态值
                setState(c);
                return free;
            }

#### FairSync ####

公平锁`FairSync`的区别在于,它的获取锁的实现在它的内部,`Sync`默认内部实现了非公平锁

static final class FairSync extends Sync {
            private static final long serialVersionUID = -3000897897090466540L;
    
            // 这个方法最终调用 tryAcquire
            final void lock() {
                acquire(1);
            }
    
            // 公平锁的实现
            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()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
        }

它的实现比较简单，通过实现可以发现，它按照申请锁的顺序来获取锁，排第一的先拿到锁，在结合上面的概念理解一下，就很好理解了.

释放锁`unlock`，上面我们已经讲过了~

### 结束语 ###

本节内容可能有点多，主要是看源码，可以打断点自己调一下, 举一反三,通过源码去理解一下什么是`公平锁和非公平锁`, `ReentrantLock`可重入锁体验在哪里。

关注关注，主页更多java内容

![a7650bbd12df446c839ae0882232aa35.jpeg][]

[a7650bbd12df446c839ae0882232aa35.jpeg]: https://img-blog.csdnimg.cn/a7650bbd12df446c839ae0882232aa35.jpeg