API及性质-ReentrantLock入门-并发编程(Java)

最新推荐文章于 2023-04-29 23:08:19 发布
最新推荐文章于 2023-04-29 23:08:19 发布
阅读量211 收藏
点赞数 1
分类专栏： # 并发编程 文章标签： 并发编程 ReentrantLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaogzhen/article/details/120176478
版权

文章目录

1、可重入

可重入是指同一线程如果首次获得了这把锁，那么因为是这把锁的拥有者，因此有权利再次获取这边锁。

/**
 * 测试ReentrantLock可重入性
 */
@Slf4j(topic = "c.TestReentrant")
public class TestReentrant {
   static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        method1();
    }

    public static void method1() {
        log.debug("执行方法1");
        try {
            lock.lock();
            log.debug("获得锁，调用方法2");
            method2();
        }finally {
            lock.unlock();
        }
    }
    public static void method2() {
        log.debug("执行方法2");
        try {
            lock.lock();
            log.debug("获得锁");
        }finally {
            lock.unlock();
        }
    }
}

2、可打断

可打断指在线程等待过程中，可以被打断。

  • 方法：lock.lockInterruptibly() 尝试获取锁，如果获取不到锁，进入等待；等待过程中可以被打断。
/**
 * 测试ReentrantLock可打断性
 */
@Slf4j(topic = "c.TestInterruptible")
public class TestInterruptible {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            try {
                // 尝试获取锁
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("获取锁失败，退出.");
                return;
            }
            try {
                log.debug("获取到锁,执行后续代码...");
            } finally {
                lock.unlock();
            }
        }, "t1");

        // 主线程先获取了锁
        lock.lock();

        t1.start();
        TimeUnit.SECONDS.sleep(1);
        log.debug("打断t1线程...");
        t1.interrupt();
    }
}

当使用如果获取锁调用的是lock.lock(),那么线程等待不会被打断，

/**
 * 测试ReentrantLock可打断性
 */
@Slf4j(topic = "c.TestInterruptible")
public class TestInterruptible {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
//            try {
//                // 尝试获取锁
//                lock.lockInterruptibly();
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//                log.debug("获取锁失败，退出.");
//                return;
//            }

            try {
                // 尝试获取锁
                lock.lock();
                log.debug("获取到锁,执行后续代码...");
            } finally {
                lock.unlock();
            }
        }, "t1");

        // 主线程先获取了锁
        lock.lock();

        t1.start();
        TimeUnit.SECONDS.sleep(1);
        log.debug("打断t1线程...");
        t1.interrupt();
    }
}

3、锁超时

可打断能避免一直等待，防止死锁。锁超时呢，是主动性的。线程尝试获取锁，如果获取不到锁，不会一直等待。

  • 方法：lock.tryLock()

  • 方法：lock.tryLock(long timeout, TimeUnit unit)

    • timeout ：超时时间
    • unit：时间单位

  • 测试无参tryLock()

    /**
 * 测试ReentrantLock 锁超时-tryLock无参
 */
@Slf4j(topic = "c.TestTryLock01")
public class TestTryLock01 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            if(!lock.tryLock()) {
                log.debug("没有获取锁，退出");
                return;
            }
            try {
                log.debug("获取到锁，执行后续代码。。。");
            }finally {
                lock.unlock();
            }
        }, "t1");

        // 主线程先获取了锁
        lock.lock();

        t1.start();
    }
}

  • 测试带参tryLock

    /**
 * 测试ReentrantLock 锁超时-tryLock带参
 */
@Slf4j(topic = "c.TestTryLock02")
public class TestTryLock02 {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            try {
                if(!lock.tryLock(1, TimeUnit.SECONDS)) {
                    log.debug("没有获取锁，退出");
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                log.debug("获取锁失败，退出");
                return;
            }
            try {
                log.debug("获取到锁，执行后续代码。。。");
            }finally {
                lock.unlock();
            }
        }, "t1");

        // 主线程先获取了锁
        lock.lock();
        Thread.sleep(100);
        t1.start();
    }
}

4、锁超时解决哲学家进餐问题

  • 分析：

之前之所以会出现死锁现象，因为线程在获取另外一根筷子（锁）时，如果获取失败，就会无限等待；这里我们用tryLock超时等待方式，线程在获取另外一根筷子（锁）时，如果获取失败，不等待或者有时限的等待，同时放弃已经获取的筷子；

/**
 * 筷子类
 */
@Data
@AllArgsConstructor
public class Chopstick  extends ReentrantLock {
    /** 筷子名称 */
    private String name;
}

/**
 * 哲学家类
 */
@Slf4j(topic = "c.Philosopher")
@Data
public class Philosopher extends Thread{
    /** 左手边筷子名称 */
    private Chopstick left;
    /** 右手边筷子名称 */
    private Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while (true) {
            // 尝试获取左手边的筷子
            if (left.tryLock()) {
                try {
                    // 尝试获取右手边的筷子
                    if (right.tryLock()) {
                        try {
                            // 拿到了一双筷子，开始吃饭
                            eat();
                        } finally {
                            // 然后释放锁
                            right.unlock();
                        }
                    }
                }finally {
                    // 1、正常执行，吃饭后放下筷子
                    // 2、获取右手边筷子失败，那么就放下已经获取到的左筷子，防止死锁
                    left.unlock();
                }
            }
        }
    }

    /**
     * 吃饭
     */
    private void eat() {
        log.debug("eating ...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 测试类
 */
@Slf4j(topic = "c.TestPhilosopherDinner")
public class TestPhilosopherDinner {
    public static void main(String[] args) {
        // 创建5根筷子
        Chopstick c1 = new Chopstick("筷子1");
        Chopstick c2 = new Chopstick("筷子2");
        Chopstick c3 = new Chopstick("筷子3");
        Chopstick c4 = new Chopstick("筷子4");
        Chopstick c5 = new Chopstick("筷子5");
        // 创建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();
    }
}

5、公平锁与不公平锁

公平：在等待队列中等待的线程，重新竞争锁对象的时候，如果遵循先来来获取，就是公平的；否则就是不公平的。

  • 在Monitor EntrList中线程竞争锁对象非公平的；

  • ReentrantLock 锁默认也是不公平的；在构造函数中设置布尔参数值为true，为公平锁

    // 源码ReentrantLock 构造方法
// 无参
public ReentrantLock() {
        sync = new NonfairSync();
    }
    
 // 有参   
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    关于底层具体怎么实现公平与不公平，我们后续详解。

6、条件变量

ReentrantLock的条件变量比synchronized强大支出在于，它支持多个条件变量（对象）。

  • synchronized那些不满足条件的线程进入一个等待队列
  • 而ReentrantLock支持多个条件变量对象（队列）；线程可根据情况选择进入那个队列等待；同样根据条件唤醒在不同等待队列中等待的线程。

过程：

  • 等待状态的线程获取锁对象。
  • 因为不满足某个条件，进入ConditionObject等待
  • ConditionObject等待的线程被唤醒（或打断或超时），重新竞争锁对象

相关对象和方法

  • 对象：Condition 条件变量，由ReentrantLock对象创建
  • 方法：condition.await()/condition.await(long tiomout) 进入条件变量等待
  • 方法：condition.signal()/condition.signalAll() 唤醒在条件变量上等等的线程

示例：以之前工地施工为例，李师傅等电接通；王师傅等柴油继续开卡车为例

@Slf4j(topic = "w.TestCondition")
public class TestCondition {

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock room = new ReentrantLock();
        // 是否又电
        AtomicBoolean hasElectric = new AtomicBoolean(false);
        // 是否有柴油
        boolean hasDiesel = false;
        // 等电的休息室
        Condition electric = room.newCondition();
        // 等柴油的休息室
        Condition diesel = room.newCondition();
        new Thread(() -> {

            room.lock();
            try {
                log.debug("电有了没？[{}]", hasElectric);
                while (!hasElectric.get()) {
                    log.debug("没电，先歇会！");
                    try {
                        electric.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("电接通了？[{}]", hasElectric);
                if (hasElectric.get()) {
                    log.debug("开始干活！");
                }
            } finally {
                room.unlock();
            }

        }, "李师傅").start();

        new Thread(() -> {

            room.lock();
            try {
                log.debug("柴油送到没？[{}]", hasElectric);
                while (!hasDiesel) {
                    log.debug("柴油没送到，先歇会！");
                    try {
                        diesel.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("柴油送到没？[{}]", hasElectric);
                if (hasDiesel) {
                    log.debug("开始干活！");
                }

            } finally {
                room.unlock();
            }
        }, "王师傅").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {
            try {
                room.lock();
                hasElectric.set(true);
                log.debug("电接通了！");
                electric.signal();
            } finally {
                room.unlock();
            }
        }, "工人").start();
    }
}

仓库地址：https://gitee.com/gaogzhen/concurrent

gaog2zh
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ReentrantLock api 详解
小白爱学习的专栏
06-22 610
今天学习ReentrantLock工具类，该类是JUC原子包中的类，通过单元测试代码把所有public api方法跑了一遍，大致了解了底层实现，初学乍练，有很多一知半解的地方，待后续有了深入理解再来补充 package test.java.util.concurrent.locks; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurren
Java并发编程——ReentrantLock
wait2023的博客
05-23 179
1 类图结构 ReentrantLock是JUC包下的一个独占锁，类图结构如下： 可以看到，其实现了Lock接口，并且底层是通过AQS抽象同步队列来实现的，我们直到AQS中有一个state状态变量，在ReentrantLock，state = 0时表示该锁还未被任何线程持有，大于1时则表示该锁已经被线程所持有，并且表示了该锁的重入次数。其中Sync是该类的一个内部类，NonfairSync和FaiSync分别对应获取锁的非公平与公平策略。对于这个锁，我们常用的就是lock与unlock方法，再就是C
java多线程-ReentrantLock重入锁的使用及常用API
weixin_34101784的博客
06-17 881
1 ReentrantLock重入锁 和关键字synchronization相比，重入锁有着显示的操作过程。需要手动指定何时加锁，何时释放锁。重入锁对逻辑控制的灵活性要远远优于关键字synchronization。 在退出时，必须记得释放锁，否则其他线程就没有机会访问。 重入锁之所以叫重入锁，是因为这种锁能反复进入。但是只限于一个线程。 //锁定几个就要释放几个 try{ lock.lock()...
浅析ReentrantLock的使用
Peppa_Pig_0325的博客
03-25 212
目录 ReentrantLock的API介绍 Condition的API介绍 ReentrantLock的使用实例 一、ReentrantLock的API介绍 ReentrantLock reentrantLock = new ReentrantLock(); /** * 获取锁，如果获取不到锁， 则一直阻塞 ...
ReentrantLock详解
weixin_44906791的博客
04-29 1264
ReentrantLock是一种可重入的独占锁，它允许同一个线程多次获取同一个锁而不会被阻塞。它的功能类似于synchronized是一种互斥锁，可以保证线程安全。可中断可以设置超时时间可以设置为公平锁支持多个条件变量与 synchronized 一样，都支持可重入它的主要应用场景是在多线程环境下对共享资源进行独占式访问，以保证数据的一致性和安全性。示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
jdk8 ReentrantLock API 快速上手（配测试代码）
秀强的专栏
09-09 342
文章目录ReentrantLocktryLocklockInterruptibly()公平锁 ReentrantLock Reentrantlock可用于替代synchronized ReentrantLock是显式锁，锁的持有和释放都必须手动编写（重要的事情说三遍）。 使用synchronized锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进...
Java实战小技巧（六）：并发编程之ReentrantLock类
The Blog of Coder
05-06 292
Java中实现独占锁的方法除了使用关键字synchronized外，还可以使用ReentrantLock类。ReentrantLock和synchronized都是独占锁、重入锁，二者在性能上没有区别，但ReentrantLock的功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。synchronized的优点是操作简单，一般简单的并发场景使用synchronized就够了。
java并发编程从入门到精通
02-14
上述提及的知识点，如线程的基本概念、并发集合、锁机制、线程池的使用、线程同步与通信的模式等，都是《java并发编程从入门到精通》这本书的前三章可能会涉及的内容。尽管这里只能提供试读版的内容，但通过阅读和...
计算机后端-Java-Java高并发从入门到面试教程-用拆分思路.zip
05-21
通过对这些知识点的学习，开发者不仅能掌握Java并发编程的核心概念，还能具备解决实际问题的能力，为职场发展和面试提供有力支持。在实际项目中，运用这些理论和实践经验，可以编写出更加高效、可靠的并发代码，提升...
计算机后端-Java-Java高并发从入门到面试教程-发课程资料.zip
05-21
Java高并发编程是Java开发中的核心技能之一，尤其在大型互联网应用中不可或缺。这个课程资料主要涵盖了从基础知识到面试必备的Java并发知识体系。以下是对这些主题的详细讲解： 1. **并发基础** - **线程与进程**...
计算机后端-Java-Java高并发从入门到面试教程-.C组件拓展.zip
05-21
4. **Java内存模型**：JMM（Java Memory Model）规定了线程如何访问共享变量，理解内存屏障和重排序对并发的影响是高级Java并发编程的关键。 5. **死锁与活锁**：学习如何识别和避免死锁（两个或多个线程互相等待...
计算机后端-Java-Java高并发从入门到面试教程-务降级与服.zip
05-21
本教程专注于Java高并发编程，这是现代软件系统设计中的关键部分，特别是在处理大量用户请求和服务之间交互时。"务降级与服务"是这个主题的一个重要概念，它涉及到在系统负载过高或者资源紧张时如何确保核心业务的...
ReentrantLock API
weixin_30628077的博客
05-04 184
　　java可重入锁，简单几个小案例，测试特性。 　　1.尝试锁 tryLock package com.cn.cfang.ReentrantLock; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks....
Java多线程编程-ReentrantLock(2)
HQ DevJ的专栏
04-08 251
Java多线程编程-ReentrantLock公平锁和非公平锁使用ReentrantLock实现公平锁公平锁ReentrantLock相关APIReentrantLock.getHoldCount()ReentrantLock.getQueueLength()ReentrantLock.getWaitQueueLength(Condition condition)ReentrantLock.isFair()ReentrantLock.hasQueuedThread(Thread thread)Reentra
ReentrantLock入门讲解
Hi_Red_Beetle的博客
05-27 669
一、概述 ReentrantLock字面意思就是可重入锁（re表示重新，entrant表示进入，lock表示锁），它其实是属于JUC包（java,util.concurrent）下的一个类。在多线程环境下我们为了避免并发引发的一些问题常常会选择给可能引起并发问题的代码（临界区）加锁，说到加锁大家最熟悉的可能就是synchronized关键字，除此以外的另一个就是ReentrantLock类。ReentrantLock相比于synchronized有如下特点： 可中断 可以设置超时时间 可以设置为公平
ReentrantLock简单图解学习
_heng_的博客
04-29 1255
写这篇文章是让自己对AQS和ReentrantLock加深理解,需要配合之前的文章一起学习。AQS(AbstractQueuedSynchronizer)初学java ReentrantLock(可重入锁)初学假设有3个线程A、B、C都调用lock.lock()方法获取锁，ReentrantLock 默认的构造方法调用的是非公平锁public ReentrantLock() {        sy...
ReentrantLock加锁与解锁
qq_20265015的博客
01-18 428
1. ReentrantLock非公平锁加锁流程 首先尝试CAS的方式将state从0改为1，改成功就将当前的线程所有者改为自己。 final void lock() { //调用CAS尝试获取锁 if (compareAndSetState(0, 1)) //尝试成功则修改当前拥有锁的线程是自己 setExclusiveOwnerThread(Thread.currentThread()); else //获取失败 acquire(1)
记录自己分析ReentrantLock加锁与解锁及相关API的详细流程
qq_40246487的博客
10-29 164
下面是ReentrantLock非公平锁加锁流程： final void lock() { //调用CAS尝试获取锁 if (compareAndSetState(0, 1)) //尝试成功则修改当前拥有锁的线程是自己 setExclusiveOwnerThread(Thread.currentThread()); else //获取失败 acquire(1); } public final void acquire(int arg)
java源码资源学生课程管理系统java源码资源学生课程管理系统
最新发布
08-24
java源码资源学生课程管理系统java源码资源学生课程管理系统提取方式是百度网盘分享地址
Java并发编程实践：深入理解ReentrantLock
"Java并发编程实践的第七章主要聚焦于显示锁的概念，特别是Lock接口和ReentrantLock类的使用。这一章深入探讨了Java 5.0引入的重入锁如何提供高级特性，以增强对共享对象访问的控制，同时在性能上优于传统的内部锁。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gaog2zh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值