美文网首页
面试官: 有了解过ReentrantLock的底层实现吗?说说看

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

作者: Java码农 | 来源:发表于2022-06-17 14:30 被阅读0次

    我们可以了解到它是一个可重入锁,下面我们就一起看一下它的底层实现~

    构造函数

    我们在使用的时候,都是先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可重入锁体验在哪里。

    相关文章

      网友评论

          本文标题:面试官: 有了解过ReentrantLock的底层实现吗?说说看

          本文链接:https://www.haomeiwen.com/subject/amfhvrtx.html