ReentrantLock功能详解

最新推荐文章于 2022-11-11 09:08:05 发布
最新推荐文章于 2022-11-11 09:08:05 发布
阅读量3.3k 收藏 3
点赞数 5
分类专栏： Java基础 并发编程 文章标签： ReentrantLock Condition 三个线程交替打印ABC 可中断锁 可重入锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Baisitao_/article/details/102062329
版权

前言

Java里的锁主要分为两种：Synchronized关键字和java.util.concurrent.locks.Lock接口的实现类。之前也写过几篇关于Synchronized的博客：synchronized关键字（一）：实现原理。所以本篇主要讲解ReentrantLock功能使用、与Synchronized关键字的区别等等

ReentrantLock

废话不多说，先来看看ReentrantLock的使用。实例中涉及到了线程池和CountDownLatch的简单使用，如果还不太了解，请先简单浏览下这两篇
线程池使用
并发工具三巨头CountDownLatch、CyclicBarrier、Semaphore使用

public class LockDemo {

    // 并发线程数量
    private static final int THREAD_COUNT = 5;
    // 计数变量
    private static int count = 0;
    private static final Lock lock = new ReentrantLock();
    private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.submit(() -> {
                for (int j = 0; j < 10000; j++) {
                    // 加锁
                    lock.lock();
                    try {
                        count++;
                    } finally {
                        // 解锁
                        lock.unlock();
                    }
                }
                // 计数器-1操作
                latch.countDown();
            });
        }

        // 保证线程池中的任务都执行完成
        latch.await();
        System.out.println(count);
        // 关闭线程池
        executor.shutdown();
    }
}

执行结果毫无疑问是50000，也就是说ReentrantLock通过lock()和unlock()两个方法可以实现和Synchronized关键字同样的效果，并且用法也比较简单。

Condition

ReentrantLock除了单独使用外，还可以与Condition结合使用，实现类似wait/notify机制的效果

public class LockConditionDemo {

    public static void main(String[] args) {
        final Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        Thread thread1 = new Thread(() -> {
            try {
                lock.lock();
                System.out.println(System.currentTimeMillis() + " -> thread-1 -> lock()");    // 1
                // 模拟耗时操作
                Thread.sleep(500);
                System.out.println(System.currentTimeMillis() + " -> thread-1 -> await()");   // 2
                condition.await();
                System.out.println(System.currentTimeMillis() + " -> thread-1 -> continue");  // 6
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                lock.lock();
                System.out.println(System.currentTimeMillis() + " -> thread-2 -> lock()");    // 3
                // 模拟耗时操作
                Thread.sleep(200);
                System.out.println(System.currentTimeMillis() + " -> thread-2 -> signal()");  // 4
                condition.signal();
                System.out.println(System.currentTimeMillis() + " -> thread-2 -> continue");  // 5
                // 模拟耗时操作
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        thread1.start();
        thread2.start();
    }
}

执行结果

1570171477295 -> thread-1 -> lock()
1570171477797 -> thread-1 -> await()
1570171477797 -> thread-2 -> lock()
1570171477997 -> thread-2 -> signal()
1570171477997 -> thread-2 -> continue
1570171478198 -> thread-1 -> continue

输出顺序已经标记到了每行输出代码的后面，从输出结果可以看出：thread1首先获得锁，执行输出thread-1 -> lock()，休眠500毫秒后执行condition.await()，阻塞thread1，并释放锁。thread2马上获得锁，输出thread-2 -> lock()，休眠200毫秒后执行condition.signal()，唤醒thread1，自己继续执行。此时thread1处于等待锁的状态，只有thread2执行lock.unlock()释放了锁后，thread1才能重新获取锁，继续执行。

可重入性

ReentrantLock翻译过来就是可重入锁，自然是支持可重入的，也很容易验证，示例如下

public class LockDemo {
    // 并发线程数量
    private static final int THREAD_COUNT = 5;

    // 计数变量
    private static int count = 0;
    private static final Lock lock = new ReentrantLock();
    private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.submit(() -> {
                for (int j = 0; j < 10000; j++) {
                    // 加锁
                    lock.lock();
                    // 再次加锁
                    lock.lock();
                    try {
                        count++;
                    } finally {
                        // 解锁
                        lock.unlock();
                        // 再次解锁
                        lock.unlock();
                    }
                }
                // 计数器-1操作
                latch.countDown();
            });
        }
        // 保证线程池中的任务都执行完成
        latch.await();
        System.out.println(count);

        // 关闭线程池
        executor.shutdown();
    }
}

执行结果毫无疑问是50000，这个示例只是把第一个示例稍微修改了一下，分别加锁了2次，解锁了2次。并不会影响输出结果，也没有死锁。这个例子也提醒我们，加锁了多次，一定要解锁同样的次数。

与Synchronized的区别

到现在为止，似乎还只是演示了ReentrantLock和Synchronized同样的功能，Synchronized能做到，ReentrantLock都可以做到。
ReentrantLock与Synchronized的区别主要体现在以下几点：

  • 实现方式：Synchronized由JVM实现，所有JDK版本都支持，ReentrantLock由JDK实现，1.5及以后的版本才有
  • 性能差异：JDK1.6在Synchronized中引入了自旋锁、偏向锁、轻量级锁的优化后，性能和ReentrantLock差不多，之前的版本Synchronized效率比ReentrantLock低很多
  • 使用方式：Synchronized加锁和解锁都是由JVM自动完成的，ReentrantLock需要手动加锁和解锁
  • ReentrantLock独有的三大功能：
    • 可以指定是公平锁还是非公平锁，Synchronized只能是非公平锁
    • 可以结合Condition类实现有条件的分组唤醒，Synchronized结合wait/notify/notifyAll只能随机唤醒一个线程或者全部唤醒
    • 提供了能够中断等待锁的线程的机制
ReentrantLock指定公平锁和非公平锁

公平锁和非公平锁描述的是多个线程竞争锁的时候要不要排队，直接排队的就是公平锁；先尝试插队，插队失败再排队的就是非公平锁。其实就是先来后到，和学校食堂吃饭的时候排队一样。理解了公平锁和非公平锁，再来看看ReentrantLock相关的构造方法

public ReentrantLock() {
    sync = new NonfairSync();
}

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

这是ReentrantLock仅有的2个构造方法，根据第二个可以看出传入boolean类型的参数就可以指定公平锁还是非公平锁，第一个方法可以看出ReentrantLock默认是非公平锁。

ReentrantLock结合Condition类实现有条件的分组唤醒

假设有这样一个需求

使用三个线程Thread1、Thread2、Thread3按顺序分别交替打印A、B、C

首先分析需求Thread1打印A时，Thread2、Thread3处于阻塞状态即可，但是Thread1打印完成后需要唤醒Thread2，并且不能唤醒Thread3，再阻塞自己；同理Thread2打印完成后需要唤醒Thread3，但是不能唤醒Thread1，再阻塞自己，依次循环，实现按顺序交替打印，这里明显就需要有条件的唤醒线程。

public class LockConditionDemo {

    private static final Lock lock = new ReentrantLock();
    private static Condition conditionA = lock.newCondition();
    private static Condition conditionB = lock.newCondition();
    private static Condition conditionC = lock.newCondition();
    private static volatile int permit = 0;

    public static void main(String[] args) {
    
        Thread thread1 = new Thread(() -> {
            try {
            	// 休眠200毫秒，验证并不是thread1运气好，才最先输出
                Thread.sleep(200);
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while ((permit % 3) != 0) {
                        conditionA.await();
                    }
                    System.out.print("A");
                    permit++;
                    conditionB.signal();
                }
                conditionB.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while ((permit % 3) != 1) {
                        conditionB.await();
                    }
                    System.out.print("B");
                    permit++;
                    conditionC.signal();
                }
                conditionC.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        });
        
        Thread thread3 = new Thread(() -> {
            try {
                lock.lock();
                for (int i = 0; i < 10; i++) {
                    while ((permit % 3) != 2) {
                        conditionC.await();
                    }
                    System.out.print("C");
                    permit++;
                    conditionA.signal();
                }
                conditionA.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行结果

ABCABCABCABCABCABCABCABCABCABC

其中三个Condition对象可以决定三个线程应何时被阻塞，何时被唤醒。permit变量是为了确保Thread1最先执行，如果不要求Thread1最先执行（比如：BCABCABCA），也可以不需要permit变量，直接把condition*.await()放在condition*.signal()下面一行即可，对应关系和上述代码一样即可。

ReentrantLock提供了能够中断等待锁的线程的机制

ReentrantLock主要是靠ReentrantLock#lockInterruptibly()方法来提供一种可中断的机制。

public class LockDemo {

    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
                System.out.println(System.currentTimeMillis() + " -> thread-1 获取到了锁");
            } catch (InterruptedException e) {
                System.out.println(System.currentTimeMillis() + " -> thread-1 被中断");
            } finally {
                // lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
                System.out.println(System.currentTimeMillis() + " -> thread-2 获取到了锁");
                // 等待3秒，证明thread1一直没有获取到锁
                Thread.sleep(3000);
                System.out.println(System.currentTimeMillis() + " -> thread-2 中断thread-1");
                thread1.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        thread2.start();
        // 让thread2先启动，获取锁（仅仅是为了演示，生产环境不要用这种方式让某个线程先启动）
        Thread.sleep(200);
        thread1.start();
    }
}

执行结果

1570180667463 -> thread-2 获取到了锁
1570180670465 -> thread-2 中断thread-1
1570180670465 -> thread-1 被中断

thread-1和thread-2均用lockInterruptibly()方法尝试获取锁，thread-2获取锁后休眠3秒，期间thread-1一直无法获取锁（第9行代码没有输出），此时thread-2调用thread-1的interrupt()方法来中断thread-1，根据输出结果来看，thread-1已经被中断了。这便是ReentrantLock提供的可中断正在等待锁的线程的机制。

如何取舍

Synchronized关键字能实现的功能，ReentrantLock都能实现。但是这并不意味着我们在任何时候都要用ReentrantLock，而完全不用Synchronized。Synchronized也有自己的优势：

  • Synchronized加锁解锁由JVM完成，程序员不会忘记释放锁
  • 几乎所有的开发人员都熟悉Synchronized
  • 使用Synchronized关键字，生成线程dump文件的时候，能包括锁定信息，能标识死锁或者其他异常问题的来源。而ReentrantLock只是JDK中的一个普通类，JVM并不知道哪些线程拥有Lock对象

基于以上几点，在一般情况下，用Synchronized就行。如果真的需要ReentrantLock的三个高级功能才需要考虑使用ReentrantLock。

总结

以上就是ReentrantLock基本使用，以及和Synchronized关键字的对比，以及如何取舍这两种锁。还是那句话，只有知道了两者的区别和适用场景，才能更好的应对不同的场景，写出更优雅的并发编程代码。

Sicimike
关注
专栏目录
ReentrantLock详解
weixin_35794878的博客
07-25 196
ReentrantLock源码解析
【并发编程】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
最新发布
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
08-19 2559
【并发编程】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
详解ReentrantLock
weixin_43364551的博客
05-24 253
文章目录一、ReentrantLock的底层实现二、ReentrantLock的基本用法三、ReentrantLock的特点3.1、ReentrantLock是可重入锁3.2、ReentrantLock的公平属性 一、ReentrantLock的底层实现 我们先看看ReentrantLock类中lock()方法的实现 /** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */ final v
java ReentrantLock详解
08-26
Java ReentrantLock 详解 Java ReentrantLock 是 Java 1.5 中引入的锁机制，相比于传统的 synchronized 锁，它提供了更加灵活和强大的功能。ReentrantLock 是一种可重入锁，意味着同一个线程可以多次获得锁，而不会...
java ReentrantLock详解.docx
06-26
`ReentrantLock`是Java并发编程中的一种高级锁机制，它是`java.util.concurrent.locks`包中的类，提供了比`synchronized`关键字更丰富的功能和更细粒度的控制。相较于`synchronized`，`ReentrantLock`的主要优势在于...
ReentrantLock原理详解
qq_45827239的博客
06-16 782
文章目录前言一、ReentrantLock是如何实现的？二、lock 和 unlock的过程分析2.1 ReentrantLock的两个构造器2.2 lock过程2.3 unlock过程三、公平锁和非公平锁的区别四、Synchronized和ReentrantLock的区别4.1 功能区别4.2 性能区别4.3 ReentrantLock的特有性质 前言 了解ReentrantLock的原理和底层实现 一、ReentrantLock是如何实现的？ ReentrantLock 主要利用CAS 和 AQS队列实
ReentrantLock 详解
斜月&三星
01-08 470
一、初始ReentrantLock ReentrantLock 位于java.util.concurrent.locks包下，它实现了Lock接口和Serializable接口。ReentrantLock 是一把可重入锁和互斥锁，它具有与 synchronized 关键字相同的含有隐式监视器锁（monitor）的基本行为和语义，但是它比 synchronized 具有...
ReentrantLock解析
热门推荐
Lynn
10-25 2万+
最近学习Jdk的源代码时，读到了ConcurrentHashMap的源码实现时，发现每一个分段Segment都是ReentrantLock类型，于是顺带对ReentrantLock的源代码进行了学习。。在这里做一个笔记总结。因为只有在工作之余才能有空看看，所以思路有点零散，仅供参考。。。。 1、如何确定哪个线程可重复进入该锁                 在获取锁的时候，首先会检查
ReentrantLock 使用方法
FLY_THINK2012的博客
03-18 288
ReentrantLock是jdk5引入的新的锁机制，它与内部锁（synchronize） 相同的并发性和内存语义，比如可重入加锁语义。在中等或者更高负荷下，ReentrantLock有更好的性能，并且拥有可轮询和可定时的请求锁等高级功能。这个程序简单对比了ReentrantLock公平锁、ReentrantLock非公平锁以及内部锁的性能，从结果上看，非公平的ReentrantLock...
JUC 锁之 ReentrantLock 详解
liuwg1226的专栏
09-05 296
一 概述 先提出一些问题： 什么是可重入，什么是可重入锁? 它用来解决什么问题? ReentrantLock的核心是AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 ReentrantLock是如何实现公平锁的? ReentrantLock是如何实现非公平锁的? ReentrantLock默认实现的是公平还是非公平锁? 使用ReentrantLock实现公平和非公平锁的示例? ReentrantLock和Synchronized的对比? 接下来对 ReentrantLock 的分析，我们会一
JUC-ReentrantLock
子悠のziyou
11-11 786
ReentrantLock的功能详解与理解AQS、ReentrantLockd概述、加锁流程、可重入原理、可打断原理、公平锁原理、条件变量实现原理
【面试必问系列】之ReentrantLock详解
一个喜欢诗和远方的程序媛
01-08 3554
的队列，可以用于构建锁的基础框架，内部通过原子变量state来表示锁的状态，当state大于0的时候表示锁被占用，如果state等于0时表示没有占用锁，ReentrantLock是一个重入锁，表现在state上，如果持有锁的线程重复获取锁时，它会将state状态进行递增，也就是获得一个信号量，当释放锁时，同时也是释放了信号量，信号量跟随减少，如果上一个线程还没有完成任务，则会进行入队等待操作。而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。
ReentrantLock源码详解
Soldier_son的博客
11-27 551
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
Java ReentrantLock详解与使用
了实现Lock接口所规定的功能之外，还提供了一些私有的公共方法，这些方法使得ReentrantLock在处理复杂的同步控制场景时更为灵活。以下是ReentrantLock的一些关键特性与私有方法： 1. 可重入性：ReentrantLock允许同...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值