美文网首页程序员
ReentrantLock原理详解

ReentrantLock原理详解

作者: 洞见星河 | 来源:发表于2020-06-16 22:40 被阅读0次

    @[TOC]

    前言

    了解ReentrantLock的原理和底层实现

    一、ReentrantLock是如何实现的?

    ReentrantLock 主要利用CAS 和 AQS队列实现,并且支持公平锁和非公平锁。

    CAS:Compare and Swap,比较并交换。在java中,CAS主要由Unsafe类通过JIN调用CPU底层代码实现。

    CAS有三个参数:内存值V、预期值A、新值B。当且仅当,预期值A和内存值V相同时,将内存值修改为B,否则不做修改。

    关于AQS,参见文章AQS队列

    二、lock 和 unlock的过程分析

    2.1 ReentrantLock的两个构造器

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

    默认构造器会将其实例化为NonfairSync对象,即非公平锁,而带参数的构造器可以指定使用公平锁还是非公平锁。

    2.2 lock过程

    NonfairSync.lock

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

    非公平锁的lock方法中,首先是一个CAS操作,判断state是否是0,即当前锁是否被其他线程占用了;如果是0,则设置为1,且设置当前线程为独占线程。这里CAS操作避免了并发操作的问题。

    这里也是第一处体现非公平锁:如果此处占用锁的线程刚刚好释放锁,则当前线程可以直接获取锁,而无需排队,相当于直接“插队”。

    若此处没有设置成功,即没有获取锁,则会执行acquire()方法。
    acquire()

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

    第一步是调用tryAcquire()方法,尝试获取锁。

    final boolean nonfairTryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) { //状态为0,没有线程占用锁
                    if (compareAndSetState(0, acquires)) {
                        //与lock方法里一样,直接获取锁
                        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; // 获取锁失败,返回false
            }
    

    这里第二次体现了不公平锁。

    这里还检验了是不是当前线程已经获取锁,而又重新获取锁。这里体现了重入锁。会更新状态值为重入的次数。

    第二步addWaiter(Node.EXCLUSIVE)。

    private Node addWaiter(Node mode) {
            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;
        }
    

    这个添加到队列的方法在上篇文章AQS已经分析过了,就不详细分析了。

    第三步acquireQueued(),此方法是让队列中的线程尝试获取锁,如果失败则挂起线程。

    final boolean acquireQueued(final Node node, int arg) {
            boolean failed = true; // 标记是否获取锁成功
            try {
                boolean interrupted = false; // 线程中断标志
                for (;;) {  // 自旋
                    final Node p = node.predecessor();  // 获得前驱节点
                    // 如果该节点的前驱节点是head,则该节点是队列中的第一个线程,可以尝试互殴去锁
                    if (p == head && tryAcquire(arg)) { 
                        setHead(node); // 获取锁成功
                        p.next = null; // help GC,不然GC无法回收
                        failed = false; // 获取锁成功
                        return interrupted; //返回中断标志,没有被中断
                    }
                    // 如果获取失败,是否可以挂起
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally {
                if (failed)
                    cancelAcquire(node); // 最后取消尝试获取锁
            }
        }
    

    当上述方法获取锁失败之后,就会判断线程是否需要挂起。下面说明下shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()方法。

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
            // 前驱节点的状态
            int ws = pred.waitStatus;
            if (ws == Node.SIGNAL)
                /*
                 * This node has already set status asking a release
                 * to signal it, so it can safely park.
                 */
                return true; // 如果前驱节点状态是SIGNAL,则返回true,可以挂起
            // 前驱节点是CANCELLED
            if (ws > 0) {
                /*
                 * Predecessor was cancelled. Skip over predecessors and
                 * indicate retry.
                 */
                // 从队尾向前循环查找,直到找到第一个不为CANCELLED的节点
                do {
                    node.prev = pred = pred.prev;
                } while (pred.waitStatus > 0);
                pred.next = node;
            } else {
                /*
                 * waitStatus must be 0 or PROPAGATE.  Indicate that we
                 * need a signal, but don't park yet.  Caller will need to
                 * retry to make sure it cannot acquire before parking.
                 */
                // 设置前驱节点状态为SIGNAL
                compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
            }
            return false;
        }
     // 挂起当前线程,并返回线程中断状态
     private final boolean parkAndCheckInterrupt() {
            LockSupport.park(this);
            return Thread.interrupted();
        }
    

    这里解释下,线程挂起的前提是,前驱节点是SIGNAL状态。那SIGNAL状态的含义是什么?SIGNAL表示其前驱节点线程如果获取锁,退出队列,则将其唤醒。

    2.3 unlock过程

    unlock

    public void unlock() {
            sync.release(1);
        }
    public final boolean release(int arg) {
            if (tryRelease(arg)) { // 尝试释放锁
                Node h = head; // 获取头节点
                if (h != null && h.waitStatus != 0)
                    unparkSuccessor(h); // 如果头节点不为空且不为状态不为0,则取消挂起
                return true; // 释放成功
            }
            return false; // 释放失败
        }
    

    这里先尝试释放锁,如果成功,就将头节点取消挂起。

    tryRealase

    protected final boolean tryRelease(int releases) {
                // 当前锁状态值减去释放值,注意考虑重入锁,不是直接置为0
                int c = getState() - releases;
                // 如果不是当前线程占用锁,则抛出异常
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                if (c == 0) { // 如果状态值等于0,则释放锁成功
                    free = true;
                    // 清空独占线程
                    setExclusiveOwnerThread(null);
                }
                // 更新state 值
                setState(c);
                return free;
            }
    

    三、公平锁和非公平锁的区别

    下面介绍非公平锁和公平锁的区别,公平锁在获取锁之前, 不会直接CAS去获取锁,而是先判断当前锁状态是不是等于0且当前线程是不是队列中第一个线程,state=0才去尝试获得锁。

    protected final boolean tryAcquire(int acquires) {
                // 获取当前线程
                final Thread current = Thread.currentThread();
                // 获取锁状态
                int c = getState();
                if (c == 0) { // 如果锁没有被任何线程拥有
                    // 当前线程是CLH队列的的第一个线程,则取获取锁
                    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;
            }
        }
    

    四、Synchronized和ReentrantLock的区别

    4.1 功能区别

    Synchronized是Java语言的关键字,是通过JVM实现的。

    ReentrantLock是API层面的一种互斥锁,而且它的锁粒度和灵活性都优于Synchronized。

    Synchronized使用较为简单方便,由编译器去保证锁的加锁和释放。而ReentrantLock需要手动加锁和释放锁,如果忘记手工释放锁,会造成死锁。

    4.2 性能区别

    在Synchronized优化之前,性能是比较差的,因为都是重量级锁。但是Synchronized引入偏向锁,轻量级锁之后,两者的性能相差不大。当不需要使用ReentrantLock的特有性质时,官方建议使用Synchronized。

    4.3 ReentrantLock的特有性质

    等待可中断:持有锁的线程长期不释放的时候,正在等待的线程可以选择放弃等待,这相当于Synchronized来说可以避免出现死锁的情况。通过lock.lockInterruptibly()来实现这个机制。

    公平锁:多个线程等待同一个锁时,必须按照申请锁的时间顺序获得锁,Synchronized锁是非公平锁,ReentrantLock可以实现公平锁。

    选择性通知(锁绑定多个条件):一个ReentrantLock可以同时绑定多个对象,然后通过condition(条件)类,来分组唤醒线程,而Synchronized是随机唤醒一个线程或者所有线程。

    相关文章

      网友评论

        本文标题:ReentrantLock原理详解

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