ReentrantLock各种加锁方式源码分析(公平，非公平，可中断，可定时加锁)

最新推荐文章于 2024-11-04 01:00:00 发布

weixin_44029692

最新推荐文章于 2024-11-04 01:00:00 发布

阅读量195

点赞数

分类专栏： java并发源码解析多线程文章标签： java 并发编程多线程

本文链接：https://blog.youkuaiyun.com/weixin_44029692/article/details/106853356

版权

java并发同时被 3 个专栏收录

10 篇文章

订阅专栏

源码解析

10 篇文章

订阅专栏

多线程

8 篇文章

订阅专栏

本文深入分析了ReentrantLock的四种加锁方式：公平锁、非公平锁、可定时加锁及可中断加锁。通过对比公平锁与非公平锁的实现，探讨了它们在尝试获取锁时的区别。同时，详细阐述了可定时加锁的实现原理，包括如何处理超时和中断情况。最后，介绍了可中断加锁如何响应中断信号。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

之前我们分析过AbstractQueuedSynchronizer的独占锁的获取与释放的源码，ReentrantLock是基于AbstractQueuedSynchronizer的独占锁实现的锁，今天我们来分析它各种加锁的方式，比如公平锁，非公平锁，可中断加锁，一定时间加锁等。

一：公平锁与非公平锁

public class ReentrantLock implements Lock, java.io.Serializable {
 
    private final Sync sync;
    //内部的Sync继承了AQS，Sync有两个子类，如下
    abstract static class Sync extends AbstractQueuedSynchronizer {
        ...
    }
    
    // 非公平实现
    static final class NonfairSync extends Sync{
        ...
    }
    
    // 公平实现
    static final class FairSync extends Sync {
        ...
    }   
}

ReentrantLock的内部类Sync 继承了AbstractQueuedSynchronizer ，并且有公平和非公平两种实现：
先来看公平锁的实现：

static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

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

公平锁lock()直接调用了AQS的acquire(1)方法，我们看看它重写的tryAcquire()是什么样的：

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 首先获取当前锁的状态
            int c = getState();
            // c = 0 说明当前锁没被任何线程占用, 可以尝试获取锁
            if (c == 0) {
                // 因为是公平锁, 所以在获取锁之前首先看看队列中有没有排在自己前面的Node
                if (!hasQueuedPredecessors() &&
                    // 如果没有人在排队, 则通过CAS方式获取锁
                    compareAndSetState(0, acquires)) {
                    // 获取成功，把占用锁的线程设为自己
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 说明state不0，锁被某个线程获得了
            // 因为是可重入锁，所以需要判断获取锁的是不是当前的线程，是的话把状态加acquires
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            // 到这里说明有人占用了锁, 并且占用锁的不是当前线程, 那么获取锁失败
            return false;
        }

对于公平锁来说的话，如果当前锁没有被获取，首先看看队列中有没有排在自己前面的Node，如果没有的话，才可以去尝试获取锁，如果队列中有排在自己前面的Node，那么只能加到阻塞队列中去了。

我们看看它是怎么判断队列中排在前面的Nodede :

public final boolean hasQueuedPredecessors() {
        Node t = tail; 
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

head不等于tail说明有Node在排队，并且s.thread != Thread.currentThread()说明第一个排队的不是当前线程，那么返回true，这样的话当前的线程就不能去获取锁；

我们再来看看非公平锁是怎么是实现的：

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        

        final void lock() {
            // 首先直接尝试CAS去获取锁
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 不成功，再去调用AQS的acquire()方法
                acquire(1);
        }

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

我们可以看到非公平锁首先直接尝试CAS去获取锁，尝试失败之后，再去调用了AQS的acquire(1)方法，它tryAcquire()的实现在nonfairTryAcquire(acquires)方法里面，这个方法在分析AQS的时候分析过，我们来看一下它的实现：

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 获取state的状态
            int c = getState();
            // state为0，表示锁还没有被线程获取
            if (c == 0) {
                // 这时候就可以CAS去获取锁
                if (compareAndSetState(0, acquires)) {
                    // CAS成功，把获取锁的线程设为当前线程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 说明state不0，锁被某个线程获得了
            // 因为是可重入锁，所以需要判断获取锁的是不是当前的线程，是的话把状态加acquires
            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;
        }

我们可以看到，跟公平锁不同的是，如果当前锁没有被获取，那么尝试直接获取锁，获取失败了，再加入到阻塞队列中去。

对于ReentrantLock来说，它的非公平锁和公平锁有两个区别：

对于非公平锁，一上来，不管三七二十一，直接尝试CAS获取锁，如果获取失败，俺么调用AQS的acquire()方法，而公平锁直接调用AQS的acquire()方法；
在tryAcquire()中，对于非公平锁，如果锁没有被获取的话，那么它会尝试CAS获取锁，而对于公平锁，如果队列中没有排在自己前面的Nod的话，才可以去尝试获取锁，如果队列中有排在自己前面的Node，那么不可以去获取锁。

二：可定时加锁

ReentrantLock里面有个tryLock()方法，可以尝试获取锁，获取不到，直接返回，而不会阻塞，我们看到其实它就是调用了非公平锁的nonfairTryAcquire(acquires)方法，源码在上面，不多说了。

public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

我们来看看可定时的tryLock(long timeout, TimeUnit unit)具体是怎么实现的：

public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

调用了tryAcquireNanos(1, unit.toNanos(timeout))，

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        return tryAcquire(arg) ||
            doAcquireNanos(arg, nanosTimeout);
    }

我们来看看 doAcquireNanos(arg, nanosTimeout)的实现：

private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        // 首先定时时间小于等于0，直接返回false
        if (nanosTimeout <= 0L)
            return false;
        // 计算过期的时间
        final long deadline = System.nanoTime() + nanosTimeout;
        // 包装成节点
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                // 拿到当前节点的前驱节点
                final Node p = node.predecessor();
                // 如果前驱节点是head节点，说明当前节点是队列中第一个等待锁的节点
                // 那么尝试再次获取锁
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                // 计算要等待的时间
                nanosTimeout = deadline - System.nanoTime();
                // 定时时间到了，直接返回false
                if (nanosTimeout <= 0L)
                    return false;
                // 往前找可以设置single的节点 
                if (shouldParkAfterFailedAcquire(p, node) &&
                    // 超时时间至少大于1000纳秒，否则自旋代替挂起，避免挂起唤醒消耗过大
                    nanosTimeout > spinForTimeoutThreshold)
                    // 使用LockSupport挂起nanosTimeout的时间
                    // 经过nanosTimeout时间后就会自动被唤醒
                    LockSupport.parkNanos(this, nanosTimeout);
                // 如果被中断过，直接抛出中断异常
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

我们可以看到，doAcquireNanos()整体的实现逻辑跟AQS的实现差不多，不过是增加了对定时的支持。
首先超时时间小于等于0，直接返回false，然后计算一下过期的时间，准备好之后，将线程包装成节点加入到阻塞队列中，如果前驱节点是head节点，说明当前节点是队列中第一个等待锁的节点，那么尝试再次获取锁，否则就去队列往前找一个可以设置single的节点，然后挂起nanosTimeout的定时时间。

对于LockSupport.parkNanos(this, nanosTimeout)，当挂起的时间到了之后，会自动被唤醒。然后再去尝试获取锁，如果不成功，因为定时时间到了，只能返回false。

对于tryLock(long timeout, TimeUnit unit)来说，是响应中断的，如果LockSupport.parkNanos(this, nanosTimeout)因为中断被唤醒，那么会直接抛出中断异常。

三：可中断加锁

可中断加锁就是在等待的锁的时候可以响应中断，我们来看lockInterruptibly()方法：

public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

调用了acquireInterruptibly(1)方法

public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }

我们来看看 doAcquireInterruptibly(int arg)的实现；

private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        // 包装成节点
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                // 拿到当前节点的前驱节点
                final Node p = node.predecessor();
                // 如果前驱节点是head节点，说明当前节点是队列中第一个等待锁的节点
                // 那么尝试再次获取锁
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                // 往前找可以设置single的节点 
                if (shouldParkAfterFailedAcquire(p, node) &&
                    // 检测到是中断唤醒
                    parkAndCheckInterrupt())
                    // 直接抛出异常
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }