并发编程之ReentrantLock类使用介绍

每天早上七点三十，准时推送干货


一、简介

在之前的线程系列文章中，我们介绍到了使用synchronized关键字可以实现线程同步安全的效果，以及采用wait()、notify()和notifyAll()方法，可以实现多个线程之间的通信协调，基本可以满足并发编程的需求。

但是采用synchronized进行加锁，这种锁一般都比较重，里面的实现机制也非常复杂，同时获取锁时必须一直等待，没有额外的尝试机制，如果编程不当，可能就容易发生死锁现象。

从 JDK 1.5 开始，引入了一个高级的处理并发的java.util.concurrent包，它提供了大量更高级的并发功能，能大大的简化多线程程序的编写。

比如我们今天要介绍的java.util.concurrent.locks包提供的ReentrantLock类，一个可重入的互斥锁，它具有与使用synchronized加锁一样的特性，并且功能更加强大。

下面我们一起来学习一下ReentrantLock类的基本使用。

二、ReentrantLock 基本用法

在介绍ReentrantLock之前，我们先来看一下传统的使用synchronized对方法进行加锁的示例。

public class Counter {

    private int count;

    public void add() {
        synchronized(this) {
            count ++;
            System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
        }
    }

    public int getCount() {
        return count;
    }
}
public static void main(String[] args) throws InterruptedException {
    Counter counter = new Counter();

    // 创建5个线程，同时对count进行加一操作
    for (int i = 0; i < 5; i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.add();
            }
        }).start();
    }

    // 假设休眠1秒，5个线程执行完毕
    Thread.sleep(1000);
    System.out.println("count：" + counter.getCount());
}

输出结果如下：

ThreadName：Thread-0, count：1
ThreadName：Thread-1, count：2
ThreadName：Thread-2, count：3
ThreadName：Thread-3, count：4
ThreadName：Thread-4, count：5
count：5

如果用ReentrantLock替代，只需要将Counter中的代码改造为如下：

public class Counter {

    private final Lock lock = new ReentrantLock();

    private int count;

    public void add() {
        // 加锁
        lock.lock();
        try {
            count ++;
            System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
    
    public int getCount() {
        return count;
    }
}

运行程序，结果与上面一致，可以证明：ReentrantLock具备与synchronized一样的加锁功能。

同时，ReentrantLock还具备在指定的时间内尝试获取锁的机制，比如下面这行代码：

if (lock.tryLock(3, TimeUnit.SECONDS)) {
    try {
        ...
    } finally {
        lock.unlock();
    }
}

尝试在 3 秒内获取锁，如果获取不到就返回false，程序不需要无限等待下去，这个功能在实际开发中使用非常的广泛。

从上面的示例代码，我们可以总结出synchronized和ReentrantLock有以下几点不一样。

  • ReentrantLock需要手动调用加锁方法；而synchronized不需要，它采用了隐藏的加锁方式，借助 jvm 来实现
  • synchronized不需要考虑异常；而ReentrantLock获取锁之后，要在finally中正确的释放锁，否则会影响其它线程
  • ReentrantLock拥有尝试获取锁的超时机制，利用它可以避免无限等待；而synchronized不具备
  • synchronized是 Java 语言层面提供的语法；而ReentrantLock是 Java 代码实现的可重入锁

因此，在并发编程中，使用ReentrantLock比直接使用synchronized更灵活、更安全，采用tryLock(long time, TimeUnit unit)方法，即使未获取到锁也不会导致死锁。

三、ReentrantLock 和 synchronized 持有的对象监视器是同一个吗？

可能有的同学会发出这样的一个问题，使用ReentrantLock进行加锁和使用synchronized加锁，两者持有的对象监视器是同一个吗？

下面我们一起来看一个例子。

public class Counter {

    private final Lock lock = new ReentrantLock();

    private int count;


    public synchronized void methodA() {
        System.out.println("ThreadName：" + Thread.currentThread().getName() + "，begin methodA, count：" + getCount());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count ++;
        System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());

    }

    public void methodB() {
        // 加锁
        lock.lock();
        try {
            System.out.println("ThreadName：" + Thread.currentThread().getName() + "，begin methodB, count：" + getCount());
            Thread.sleep(3000);
            count ++;
            System.out.println("ThreadName：" + Thread.currentThread().getName() + ", count：" + getCount());
        } catch (Exception e){
          e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}
public class MyThreadA extends Thread {

    private Counter counter;

    public MyThreadA(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        counter.methodA();
    }
}
public class MyThreadB extends Thread {

    private Counter counter;

    public MyThreadB(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        counter.methodB();
    }
}
public class MyThreadTest {

    public static void main(String[] args) {
        Counter counter = new Counter();

        MyThreadA threadA = new MyThreadA(counter);
        threadA.start();

        MyThreadB threadB = new MyThreadB(counter);
        threadB.start();
    }
}

看一下运行结果：

ThreadName：Thread-0，begin methodA, count：0
ThreadName：Thread-1，begin methodB, count：0
ThreadName：Thread-0, count：2
ThreadName：Thread-1, count：2

从日志上可以看出，采用两个线程分别采用synchronized和ReentrantLock两种加锁方式对count进行操作，两个线程交替执行，可以得出一个结论：synchronized和ReentrantLock持有的对象监视器不同。

四、Condition 基本用法

在之前的文章中，我们介绍了在synchronized同步方法／代码块中，使用wait()、notify()和notifyAll()可以实现线程之间的等待／通知模型。

ReentrantLock同样也可以，只需要借助Condition类即可实现，Condition提供的await()、signal()、signalAll()原理和synchronized锁对象的wait()、notify()、notifyAll()是一致的，并且其行为也是一样的。

我们还是先来看一个简单的示例。

public class Counter {

    private final Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    private int count;

    public void await(){
        // 加锁
        lock.lock();
        try {
            condition.await();
            System.out.println("await等待结束，count：" + getCount());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }


    public void signal(){
        // 加锁
        lock.lock();
        try {
            count++;
            // 唤醒某个等待线程
            condition.signal();
            // 唤醒所有等待线程
//            condition.signalAll();
            System.out.println("signal 唤醒通知完毕");
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

public class MyThreadA extends Thread {

    private Counter counter;

    public MyThreadA(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        counter.await();
    }
}
public class MyThreadB extends Thread {

    private Counter counter;

    public MyThreadB(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        counter.signal();
    }
}
public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // 先启动执行等待的线程
        MyThreadA threadA = new MyThreadA(counter);
        threadA.start();

        Thread.sleep(3000);

        // 过3秒，再启动执行通知的线程
        MyThreadB threadB = new MyThreadB(counter);
        threadB.start();
    }
}

看一下运行结果：

signal 通知完毕
await等待结束，count：1

从结果上看很明显的看出，等待线程MyThreadA先启动，过了 3 秒之后再启动了MyThreadB，但是signal()方法先执行完毕，再通知await()方法执行,符合代码预期。

这个例子也证明了一点：condition.await()方法是释放了锁，不然signal()方法体不会被执行。

相比wait/notify/notifyAll的等待／通知模型，Condition更加灵活，理由有以下几点：

  • notify()方法唤醒线程时，被通知的线程由 Java 虚拟机随机选择；而采用ReentrantLock结合Condition可以实现有选择性地通知，这一特性在实际编程中非常实用
  • 一个Lock里面可以创建多个Condition实例，实现多路通知，使用多个Condition的应用场景很常见，比如ArrayBlockingQueue

五、小结

本文主要围绕ReentrantLock的基本使用做了一次简单的知识总结，如果有不正之处，请多多谅解，并欢迎批评指出。

六、参考

1、博客园 -五月的仓颉 - ReentrantLock的使用和Condition

2、 廖雪峰 - 使用ReentrantLock



< END >
告诉大家一个好消息，Java极客技术读者交流群（摸鱼为主），时隔 2 年后再次开放了，感兴趣的朋友，可以在公号回复：999



喜欢就分享认同就点赞

支持就在看

一键四连，你的offer也四连



相关推荐

  • 再阉割H800？美商务部新政加强限制GPU出口，预计本周公布
  • OpenAI失败大模型项目曝光；全球AI融资第三季度增27%；壁仞摩尔线程回应被列入实体清单丨AIGC大事日报
  • 重磅！《全球人工智能治理倡议》发布
  • 如何打造AR界的“遥遥领先”？对话李宏伟，雷鸟X2实测上手
  • [开源]APP服务平台，支持版本更新、推送管理，界面简洁优雅易用
  • 时序、谱域和时域特征总结。
  • 搞懂时间分片渲染！
  • 【阿里】如何实现一个 async/await
  • 代码理解技术应用实践介绍
  • GPT 对外开放，先到先得
  • 编写 if 时尽量不要带 else
  • 对三个模型生成图像的多样性进行了画鸟测试，Midjourney胜
  • 1018.AI日报：欧盟新规将大模型划分为三个级别
  • 编写一个 “Hello World” 的 Web 服务器，Go、Node.js、Nim 和 Bun 谁更快？
  • 中国大模型掌门人首次集结、全球研发中心掌门人齐聚现场，1024 程序员节「岳麓对话」重磅官宣！
  • 如何在亚马逊少走弯路？从DIY定制生意开始
  • 北大机器人当上亚运志愿者，全靠学生把多模态大模型结合具身智能
  • 算法人才vs工程人才，大模型时代谁更重要？｜对话澜舟科技
  • 超火迷你GPT-4视觉能力暴涨，GitHub两万星，华人团队出品
  • 大模型搞“人肉搜索”，准确率高达95.8%！研究作者：已提醒OpenAI谷歌Meta