Java小白系列(十三):重入锁(ReentrantLock)

作者 : 开心源码 本文共5999个字,预计阅读时间需要15分钟 发布时间: 2022-05-13 共332人阅读

一、前言

我们上一篇分析了 AQS 《小白十二》,重点讲了获取锁和释放锁的流程,AQS 是笼统类,本篇我们就来聊聊 AQS 的子类:重入锁。再正式聊重入锁前,我先提几个小问题:

  • 为什么会有重入锁?
  • 重入锁使用的场景?
  • 没有重入锁会发生什么结果?

好了,带着这几个问题,我们开始我们的重入锁之旅。

二、不可重入锁(自己实现)

JDK 中我并没有找到不可重入锁的源码,因而,只好我们手动来实现一个,看看锁不可重入的结果:

// NonReentrantLock.javapublic class NonReentrantLock {    private final AtomicReference<Thread> reference = new AtomicReference<>();    public void lock() {        Thread thread = Thread.currentThread();        while (!reference.compareAndSet(null, thread)); // CAS 加锁    }    public void unlock() {        Thread thread = Thread.currentThread();        while (!reference.compareAndSet(thread, null)); // CAS 解锁    }}

测试代码:

public class Demo implements Runnable {    private NonReentrantLock lock = new NonReentrantLock();    public static void main(String[] args) {        new Thread(new Demo()).start();    }    @Override    public void run() {        int res = fab(3);        System.out.println("3! = " + res);    }    private int fab(int n) {        System.out.println("Enter in fab............");        lock.lock();        try {            if (n <= 1) {                return 1;            }            return n * fab(n - 1);        } finally {            lock.unlock();            System.out.println("Exit in fab............");        }    }}

输出结果:

Enter in fab............Enter in fab............

我们来分析下造成这个结果的起因:

  • 第一次调用 fab 方法(传入数值3),进入并上锁;
  • 第二次调用 fab 方法(传入数值2 = 3-1),尝试上锁,因为锁已经被持有,只能CAS原地等待;
  • 由于无法拿到锁,也就无法继续执行;

结果是:死锁!

同时,我们还需要注意一点:

  • Demo 中是同一个线程;
  • 同一个线程屡次进入资源临界区;

因而,不可重入锁对于任何线程,无论是同一个线程,还是不同线程,都一视同仁,没有区别对待,那么,当存在递归时,将会发生死锁;以上的例子非常简单,我们可以想办法来避免,但实际开发中,我们很难保证同一个线程不会二次进入资源临界区而发生死锁,因而,这也是我开头提的三个小问题的解答。

三、可重入锁(自己实现)

锁通常是针对于不同线程,对同一块资源竞争时的手段,然而,当同一线程在已持有锁的情况下,屡次进入同一资源时,我们就当能够识别出来,并让其进入;但同时,我们也需要做好记录,记录持有锁的线程进入次数与退出次数,要保证进入与退出次数正好相等时,最后一次的退出才应该真正的释放锁;否则,同样也会产生死锁。

我们修改上面的例子,为了不影响之前的 demo,我们新建个类:

// CanReentrantLock.javapublic class CanReentrantLock {    private static final class LockObject {        Thread thread = null;        int count = 0;        LockObject(Thread thread) {            this.thread = thread;            this.count = 1;        }    }    private final AtomicReference<LockObject> reference = new AtomicReference<>();    public void lock() {        Thread thread = Thread.currentThread();        LockObject object = reference.get();        if (object == null) {            object = new LockObject(thread);            while (!reference.compareAndSet(null, object));        } else if (object.thread == thread ){            object.count ++;            reference.set(object);        } else {            while (!reference.compareAndSet(null, new LockObject(thread)));        }    }    public void unlock() {        Thread thread = Thread.currentThread();        LockObject object = reference.get();        if (object != null && object.thread == thread) {            object.count --;            if (object.count == 0) {                while (!reference.compareAndSet(object, null)) ;            }        }    }}

修改我们的测试类:

将下面的这行代码private NonReentrantLock lock = new NonReentrantLock();替换成private CanReentrantLock lock = new CanReentrantLock();就可

我们再次执行我们的测试用例,结果如下:

Enter in fab............Enter in fab............Enter in fab............Exit in fab............Exit in fab............Exit in fab............3! = 6

结果符合我们的预期!

四、JDK 之 ReentrantLock

ReentrantLock 就是 JDK 提供的重入锁,它有一个内部静态笼统类(Sync),继承于 AQS;同时,它还有两个静态实现类继承于 Sync,分别是:NonfairSync(非公平锁)和 FairSync(公平锁)。ReentrantLock 是独占模式,因而,Sync及其子类,需要实现三个方法:

  • isHeldExclusively:根据请求的线程与当前持有的线程进行比对来判断能否需要独占,这是重入的机制(Sync实现);
  • tryRelease:释放锁(Sync实现);
  • tryAcquire:获取锁(公平与非公平在此处实现有差异,后续会分析);

4.1、构造函数

public class ReentrantLock implements Lock, java.io.Serializable {    public ReentrantLock() {        sync = new NonfairSync();    }        public ReentrantLock(boolean fair) {        sync = fair ? new FairSync() : new NonfairSync();    }}

默认构造函数使用的是非公平锁,我们也可以指定使用公平锁。

4.2、公平锁(FairSync)

public class ReentrantLock implements Lock, java.io.Serializable {    static final class FairSync extends Sync {        /**         * 回忆一下 AQS 的获取锁流程,再结合具体的子类,整个获取锁就能串起来:         * lock -> acquire -> tryAcquire         */        final void lock() {            acquire(1);        }        protected final boolean tryAcquire(int acquires) {            final Thread current = Thread.currentThread();                        // 资源占用情况:0 = 未占用;1 = 占用            int c = getState();            if (c == 0) {                // hasQueuedPredecessors 判断 CLH 能否为空,这就表现出『公平』特性                // 假如 CLH 不为空那么就不会去竞争抢占锁                if (!hasQueuedPredecessors() &&                    compareAndSetState(0, acquires)) {                    // CLH 为空,且 CAS 成功,将 owner 设置为当前线程                    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;        }    }}

公平锁比较简单,我们来看下,非公平锁的实现。

4.3、非公平锁

public class ReentrantLock implements Lock, java.io.Serializable {    static final class NonfairSync extends Sync {        // 非公平锁,在一开始 lock 时,就先 CAS 尝试一次,假如失败则调用 acquire        final void lock() {            if (compareAndSetState(0, 1))                setExclusiveOwnerThread(Thread.currentThread());            else                acquire(1);        }            // lock 失败 -> acquire -> tryAcquire        protected final boolean tryAcquire(int acquires) {            return nonfairTryAcquire(acquires);        }    }}

我们就目前看到,非公平锁在加入 CLH 之前,利用尽可能的『机会』去尝试获取锁:

  • lock:第一次;
  • tryAcquire:尽管我们没看到实现,但是从调用的方法名上就能看出”非公平再尝试”;

4.3.1、Sync.nonfairTryAcquire

public class ReentrantLock implements Lock, java.io.Serializable {        abstract static class Sync extends AbstractQueuedSynchronizer {        abstract void lock();            final boolean nonfairTryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();            if (c == 0) {                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;        }                ......    }}

请大家仔细比照一下 FairSync.tryAcquire 方法与 Sync.nonfairTryAcquire 方法,你会发现,只有一行代码的区别:

if (c == 0) {    if (!hasQueuedPredecessors() &&        // 公平与非公平,唯一的区别        compareAndSetState(0, acquires)) {        setExclusiveOwnerThread(current);        return true;    }}

公平锁多了一个 CLH 的判断,而非公平锁再次 CAS 尝试获取锁,而无视 CLH。

4.4、静态内部笼统类Sync

public class ReentrantLock implements Lock, java.io.Serializable {        abstract static class Sync extends AbstractQueuedSynchronizer {        abstract void lock();        final boolean nonfairTryAcquire(int acquires) {            ......        }            // 释放锁;判断能否有屡次重入,直到计数为0,才释放锁        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;        }            // 独占模式,且判断能否是:重入        protected final boolean isHeldExclusively() {            return getExclusiveOwnerThread() == Thread.currentThread();        }            final ConditionObject newCondition() {            return new ConditionObject();        }        final Thread getOwner() {            return getState() == 0 ? null : getExclusiveOwnerThread();        }            final int getHoldCount() {            return isHeldExclusively() ? getState() : 0;        }            final boolean isLocked() {            return getState() != 0;        }    }}

五、总结

正由于我们详细分析了 AQS 的获取和释放锁的流程;再加上,我也用自己实现的一个例子来前后比照不可重入锁的后果;因而,我们学习 ReentrantLock 非常的轻松;至少 ReentrantLock 中的其它代码,仅仅只是 setter / getter ,并不影响核心流程;由于锁的释放比较简单,因而我就不在过多分析了,大家自己看一下就清楚了。

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » Java小白系列(十三):重入锁(ReentrantLock)

发表回复