JAVA多线程之ReentrantLock

最新推荐文章于 2024-05-17 09:00:00 发布
最新推荐文章于 2024-05-17 09:00:00 发布
阅读量1k 收藏 27
点赞数 10
分类专栏： JUC 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ifhuke/article/details/136853245
版权

文章目录

JUC中提供了很多种锁，并不止synchronized一种锁，其各有各的特点，这里我们来介绍另一种锁——ReentrantLock。

1. ReentrantLock 介绍

ReentrantLock 相对于 synchronized 具备如下特点：

  1. 锁的实现：synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的
  2. 性能：新版本 Java 对 synchronized 进行了很多优化，synchronized 与 ReentrantLock 大致相同
  3. 使用：ReentrantLock 需要手动解锁，synchronized 执行完代码块自动解锁
  4. 可中断：ReentrantLock 可中断，而 synchronized 不行
  5. 公平锁：公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁
    • ReentrantLock 可以设置公平锁，synchronized 中的锁是非公平的
    • 不公平锁的含义是阻塞队列内公平，队列外非公平
  6. 锁超时：尝试获取锁，超时获取不到直接放弃，不进入阻塞队列
    • ReentrantLock 可以设置超时时间，synchronized 会一直等待
  7. 锁绑定多个条件：一个 ReentrantLock 可以同时绑定多个 Condition 对象，更细粒度的唤醒线程
  8. 两者都是可重入锁

2. ReentrantLock 的使用

ReentrantLock 类 API：

  • public void lock()：获得锁

    • 如果锁没有被另一个线程占用，则将锁定计数设置为 1

    • 如果当前线程已经保持锁定，则保持计数增加 1

    • 如果锁被另一个线程保持，则当前线程被禁用线程调度，并且在锁定已被获取之前处于休眠状态

  • public void unlock()：尝试释放锁

    • 如果当前线程是该锁的持有者，则保持计数递减
    • 如果保持计数现在为零，则锁定被释放
    • 如果当前线程不是该锁的持有者，则抛出异常

ReentrantLock的基本语法如下：

// 获取锁
reentrantLock.lock();
try {
	// 临界区
} finally {
	// 释放锁
	reentrantLock.unlock();
}

3. 可打断

public void lockInterruptibly()：获得可打断的锁

  • 如果没有竞争此方法就会获取 lock 对象锁
  • 如果有竞争就进入阻塞队列，可以被其他线程用 interrupt 打断

注意：如果是不可中断模式，那么即使使用了 interrupt 也不会让等待状态中的线程中断

示例如下：

public static void main(String[] args) throws InterruptedException {    
    ReentrantLock lock = new ReentrantLock();    
    Thread t1 = new Thread(() -> {        
        try {            
            System.out.println("尝试获取锁");            
            lock.lockInterruptibly();        
        } catch (InterruptedException e) {            
            System.out.println("没有获取到锁，被打断，直接返回");            
            return;        
        }        
        try {            
            System.out.println("获取到锁");        
        } finally {            
            lock.unlock();        
        }    
    }, "t1");    
    lock.lock();    
    t1.start();    
    Thread.sleep(2000);    
    System.out.println("主线程进行打断锁");    
    t1.interrupt();
}

4. 锁超时

4.1 基本使用

public boolean tryLock()：尝试获取锁，获取到返回 true，获取不到直接放弃，不进入阻塞队列

public boolean tryLock(long timeout, TimeUnit unit)：在给定时间内获取锁，获取不到就退出

**注意：**tryLock 期间也可以被打断

示例如下：

public static void main(String[] args) {
    ReentrantLock lock = new ReentrantLock();
    Thread t1 = new Thread(() -> {
        try {
            if (!lock.tryLock(2, TimeUnit.SECONDS)) {
                System.out.println("获取不到锁");
                return;
            }
        } catch (InterruptedException e) {
            System.out.println("被打断，获取不到锁");
            return;
        }
        try {
            log.debug("获取到锁");
        } finally {
            lock.unlock();
        }
    }, "t1");
    lock.lock();
    System.out.println("主线程获取到锁");
    t1.start();
    
    Thread.sleep(1000);
    try {
        System.out.println("主线程释放了锁");
    } finally {
        lock.unlock();
    }
}

4.2 解决哲学家问题

哲学家问题可以使用trylock锁来解决，代码如下：

public static void main(String[] args) {
    Chopstick c1 = new Chopstick("1");//...
    Chopstick c5 = new Chopstick("5");
    new Philosopher("苏格拉底", c1, c2).start();
    new Philosopher("柏拉图", c2, c3).start();
    new Philosopher("亚里士多德", c3, c4).start();
    new Philosopher("赫拉克利特", c4, c5).start();    
    new Philosopher("阿基米德", c5, c1).start();
}
class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            if (left.tryLock()) {
                try {
                    // 尝试获得右手筷子
                    if (right.tryLock()) {
                        try {
                            System.out.println("eating...");
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                    left.unlock();
                }
            }
        }
    }
}
class Chopstick extends ReentrantLock {
    String name;
    public Chopstick(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

哲学家就餐问题可以用上述方法来进行解决，首先尝试获得左手的筷子，再尝试获得右手的筷子，不管能否获得筷子，右手释放，然后左手释放，这样，如果右手不能获得，那么也会释放左手，就不会产生死锁了。

5. 公平锁

构造方法：ReentrantLock lock = new ReentrantLock(true)

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

ReentrantLock 默认是不公平的：

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

说明：公平锁一般没有必要，会降低并发度。

6. 条件变量

ReentrantLock的条件变量可以类比synchronized 的WaitSet，synchronized 的条件变量，是当条件不满足时进入 WaitSet 等待；ReentrantLock 的条件变量比 synchronized 强大之处在于支持多个条件变量，可以理解为：

  • synchronized 是那些不满足条件的线程都在一间休息室等消息
  • ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒

Condition 类 API：

  • void await()：当前线程从运行状态进入等待状态，释放锁
  • void signal()：唤醒一个等待在 Condition 上的线程，但是必须获得与该 Condition 相关的锁

使用流程：

  • await / signal 前需要获得锁

  • await 执行后，会释放锁进入 ConditionObject 等待

  • await 的线程被唤醒去重新竞争 lock 锁

  • 线程在条件队列被打断会抛出中断异常

  • 竞争 lock 锁成功后，从 await 后继续执行

我们使用ReentrantLock来改写之前小南需要烟才能继续，小女需要外卖才能继续，以及只有一个外卖进程的例子就回变得很容易明确。

示例如下：

public class Test1 {
    static final Object room = new Object();
    static boolean hasCigarette = false;
    static boolean hasTakeout = false;
    static ReentrantLock ROOM = new ReentrantLock();
    // 等待烟的休息室
    static Condition waitCigaretteSet = ROOM.newCondition();
    // 等外卖的休息室
    static Condition waitTakeoutSet = ROOM.newCondition();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            ROOM.lock();
            try{
                while(!hasCigarette){
                    log.debug("没烟了，干不了");
                    try{
                        waitCigaretteSet.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("小南干活");
            }finally {
                ROOM.unlock();
            }
        }, "小南").start();

        new Thread(() -> {
            ROOM.lock();
            try {
                while(!hasTakeout){
                    log.debug("没外卖，干不了");
                    try{
                        waitTakeoutSet.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("小女干活");
            } finally {
                ROOM.unlock();
            }
        }, "小女").start();
        sleep(1);
        new Thread(() -> {
            ROOM.lock();
            try {
                log.debug("送来了外卖");
                hasTakeout = true;
                waitTakeoutSet.signal();
            } finally {
                ROOM.unlock();
            }
        }, "送外卖的").start();
    }
}

我们相当于建立了两个休息室，一个用来等外卖，一个用来等烟，这样，送外卖的或者送烟的来了可以精确的唤醒某一个线程。

Suppose-dilemma
关注
  • 10
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程 ReentrantLock互斥锁详解
08-25
主要介绍了Java多线程 ReentrantLock互斥锁详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程之ReentrantLock与Condition - 平凡希 - 博客园1
08-03
Java中的`ReentrantLock`是Java并发包`java.util.concurrent.locks`中的一个高级锁机制，它是可重入的互斥锁，具有与`synchronized`关键字...在设计和实现多线程程序时，了解和正确使用`ReentrantLock`是非常重要的。
多线程—ReentrantLock
qq_42251944的博客
10-21 602
你可能觉得很陌生，那我就把它和synchronized比较一下！ 与synchronized区别： 不同点： 可中断，运行代码块时，可以中断。 可以设置超时时间，例如：等待一段时间之后，还没有获取到锁，那么就放弃等待，去执行其他的任务代码。 可以设置为公平锁，可以防止线程饥饿。 支持多个条件变量，相当于有多个WaitSet等待队列，根据等待条件的不同而区分。 相同点： 都支持可重入 基本用法： //创建一个ReentrantLock对象 Reentr
2024年Java最全Java并发学习笔记：ReentrantLock，Java进阶推荐
2301_79655589的博客
05-05 669
本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取复制代码锁的获取主要是这两个函数，当然还有 lockInterruptibly( ) 和 tryLock(long timeout, TimeUnit unit) 这种响应中断和带时间限制的函数，不过和普通的lock( )和tryLock( )机理大致相同，就不介绍了。先以非公平锁的lock流程为例：// 位于Sync中if (!
5.JUC之JDK自带锁ReentrantLock
weixin_34015336的博客
09-06 210
一、初识 ReentrantLock出身自jdk1.5，中文名：可重入锁 是Java JDK自带独占锁的唯一实现，是synchronized的升级版 　　1.我们之间有个synchronized 　　我们已经认识了synchronized了，知道他能把我们实现线程同步提供原子性语义，同时又有可重入性 　　同时我们也已经知道可重入性是什么意思，也知道公平性的含义 　　可以通过...
ReentrantLock 锁详解
m0_37235955的博客
04-27 3363
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
JAVA多线程并发（六）-- ReentrantLock、Semaphore、CountDownLatch 简介
最新发布
dazhong2012的专栏
05-17 703
ReentrantLock支持公平锁和非公平锁。公平锁会按照线程请求锁的顺序来分配锁，而非公平锁则可能允许刚刚释放锁的线程再次获得锁。默认情况下，ReentrantLock创建的是非公平锁。加锁过程涉及到线程的等待队列和状态变更，而非公平锁和公平锁在加锁时的主要区别在于线程获取锁的顺序。解锁过程则相对简单，主要是将当前线程从锁的持有者中移除，并唤醒等待队列中的其他线程。在Spring应用中，我们可以使用ReentrantLock来实现对共享资源的线程安全访问。
ReentrantLock锁
weixin_47407737的博客
03-04 184
并发编程的ReentrantLock锁的介绍以及与synchronized的对比；
Java多线程中ReentrantLock与Condition详解
08-28
Java多线程中ReentrantLock与Condition详解 ReentrantLock是Java多线程中一种高级的锁机制，它实现了Lock接口，提供了与synchronized相同的并发性和内存语义，但添加了一些特性，如锁投票、定时锁等候和可中断锁...
Java多线程ReentrantLock1
08-03
总结来说，ReentrantLock在Java多线程编程中扮演着关键角色，提供了灵活的锁管理机制，包括公平性和非公平性选择，以及可中断和定时的锁获取方式。了解和熟练掌握ReentrantLock的使用，能够帮助开发者编写出高效、...
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
锁-ReentrantLock
weixin_41998947的博客
06-17 661
ReentrantLock
【锁】ReentrantLock
qq_38377525的博客
06-13 212
【锁】ReentrantLock
Java中ReentrantLock的使用
热门推荐
black_bird_cn的博客
08-25 1万+
一、基本概念 可重入锁:也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。 在JAVA中ReentrantLock 和synchronized 都是可重入锁； 重入锁ReentrantLock 相对来说是synchronized、Object.wait()和Object.notify()方法的替代品(或者说是增强版)，在JDK5.0的早期...
reentrantLock与锁
u013208718的博客
12-02 156
     lok 需要自己释放锁                synchronized 可以解决大部分需求 建议使用  JVM可以自动释放锁避免死锁
Java并发之ReentrantLock锁
墨玉浮白的博客
04-26 791
简介 一种可重入的互斥锁，经由Java5引入，支持一个线程对资源的重复加锁。它和synchronized语句和方法访问的隐式监视器锁，有相同的基本行为和语义，但是功能更强大。 一、Lock接口 锁对象，在java中锁是控制多个线程访问共享资源的方式，一个锁能防止多个线程同时访问共享资源（但有的锁就允许多个线程并发访问，如读写锁）。在Lock接口出现之前，是靠synchronized关键字来实现锁的...
ReentrantLock显示锁
weixin_30244681的博客
06-29 87
public class AttemptLocking { /* * public AttemptLocking() { * * System.out.println("构造器初始化..."); * } * * { * System.out.println("init ..."); ...
ReentrantLock锁详解
qq_44828283的博客
04-09 941
在没有接触ReentrantLock锁之前我们一直使用的是Synchronized互斥锁。Synchronized是Java的一个关键字，锁是由Jvm实现的，因此我们在使用的时候相对比较方便(无需考虑释放锁)，但是synchronized相对于我们今天介绍的ReentrantLock有以下的局限性： 1.当线程尝试获取锁的时候，若不能成功获取锁便会一直阻塞且用户无法控制 2.如果获取锁的线程休眠或者阻塞了，若不发生异常则将导致需要该锁的线程一直等待下去 了解ReentrantLock锁前了解一些概念 1.
JUC-ReentrantLock锁基础篇
zqj1172102457的博客
06-25 438
ReentrantLock是一种可重入的独占锁(互斥锁)。 独占锁: 一个线程获取()了这把锁，其他的线程则不能获取。 可重入：指的是线程A获取了这把锁，在线程A释放锁之前，线程A本身可以继续来获取这把锁。比如线程A调了了lock()方法获取了这把锁，在线程A调用unlock()方法之前，线程A本身继续调用lock()方法并不会阻塞住。重入锁的设计目的是为了解决死锁的问题。 ReentrantLock常常与Synchronized做对比，它们之间的对比如下:ReentrantLock提供的一些常用的方法有：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值