java并发编程五 ReentrantLock，锁的活跃性

多把锁

一间大屋子有两个功能：睡觉、学习，互不相干。
现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低
解决方法是准备多个房间（多个对象锁）
例子

class BigRoom {
 private final Object studyRoom = new Object();
 private final Object bedRoom = new Object();
 public void sleep() {
    synchronized (bedRoom) {
 log.debug("sleeping 2 小时");
 Sleeper.sleep(2);
        }
    }
 public void study() {
 synchronized (studyRoom) {
 log.debug("study 1 小时");
 Sleeper.sleep(1);
        }
    }
 }

将锁的粒度细分

  • 好处，是可以增强并发度
  • 坏处，如果一个线程需要同时获得多把锁，就容易发生死锁

活跃性

死锁

有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁
t1 线程 获得 A对象 锁，接下来想获取 B对象 的锁 t2 线程 获得 B对象 锁，
接下来想获取 A对象 的锁 例：

Object A = new Object();
 Object B = new Object();
 Thread t1 = new Thread(() -> {
 synchronized (A) {
 log.debug("lock A");
 sleep(1);
 synchronized (B) {
 log.debug("lock B");
 log.debug("操作...");
        }
    }
 }, "t1");
 Thread t2 = new Thread(() -> {
 synchronized (B) {
 log.debug("lock B");
 sleep(0.5);
 synchronized (A) {
 log.debug("lock A");
log.debug("操作...");
        }
    }
 }, "t2");
 t1.start();
 t2.start();

结果

12:22:06.962 [t2] c.TestDeadLock - lock B 
12:22:06.962 [t1] c.TestDeadLock - lock A

定位死锁

  • 检测死锁可以使用 jconsole工具，或者使用 jps 定位进程 id，再用 jstack 定位死锁：
cmd > jps
 Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
 12320 Jps
 22816 KotlinCompileDaemon
 33200 TestDeadLock              // JVM 进程
11508 Main
 28468 Launcher



cmd > jstack 33200
 Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
 2018-12-29 05:51:40
 Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.91-b14 mixed mode):
 "DestroyJavaVM" #13 prio=5 os_prio=0 tid=0x0000000003525000 nid=0x2f60 waiting on condition 
[0x0000000000000000]
   java.lang.Thread.State: RUNNABLE
 "Thread-1" #12 prio=5 os_prio=0 tid=0x000000001eb69000 nid=0xd40 waiting for monitor entry 
[0x000000001f54f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at thread.TestDeadLock.lambda$main$1(TestDeadLock.java:28)- waiting to lock <0x000000076b5bf1c0> (a java.lang.Object)- locked <0x000000076b5bf1d0> (a java.lang.Object)
        at thread.TestDeadLock$$Lambda$2/883049899.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)
 "Thread-0" #11 prio=5 os_prio=0 tid=0x000000001eb68800 nid=0x1b28 waiting for monitor entry 
[0x000000001f44f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at thread.TestDeadLock.lambda$main$0(TestDeadLock.java:15)- waiting to lock <0x000000076b5bf1d0> (a java.lang.Object)
        - locked <0x000000076b5bf1c0> (a java.lang.Object)
        at thread.TestDeadLock$$Lambda$1/495053715.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)
 // 略去部分输出
Found one Java-level deadlock:
 =============================
 "Thread-1":
  waiting to lock monitor 0x000000000361d378 (object 0x000000076b5bf1c0, a java.lang.Object),
  which is held by "Thread-0"
 "Thread-0":
  waiting to lock monitor 0x000000000361e768 (object 0x000000076b5bf1d0, a java.lang.Object),
  which is held by "Thread-1"
 Java stack information for the threads listed above:
 ===================================================
 "Thread-1":
        at thread.TestDeadLock.lambda$main$1(TestDeadLock.java:28)- waiting to lock <0x000000076b5bf1c0> (a java.lang.Object)- locked <0x000000076b5bf1d0> (a java.lang.Object)
        at thread.TestDeadLock$$Lambda$2/883049899.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)
 "Thread-0":
        at thread.TestDeadLock.lambda$main$0(TestDeadLock.java:15)- waiting to lock <0x000000076b5bf1d0> (a java.lang.Object)- locked <0x000000076b5bf1c0> (a java.lang.Object)
        at thread.TestDeadLock$$Lambda$1/495053715.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)
 Found 1 deadlock.
  • 避免死锁要注意加锁顺序
  • 另外如果由于某个线程进入了死循环，导致其它线程一直等待，对于这种情况 linux 下可以通过 top 先定位到 CPU 占用高的 Java 进程，再利用 top -Hp 进程id 来定位是哪个线程，最后再用 jstack 排查

活锁

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如

public class TestLiveLock {
 static volatile int count = 10;
static final Object lock = new Object();
 public static void main(String[] args) {
 new Thread(() -> {
 // 期望减到 0 退出循环
while (count > 0) {
 sleep(0.2);
 count--;
 log.debug("count: {}", count);
            }
        }, 
"t1").start();
 new Thread(() -> {
 // 期望超过 20 退出循环
while (count < 20) {
 sleep(0.2);
 count++;
 log.debug("count: {}", count);
        }
            },"t2").start()
        }, 
}

饥饿

饥饿定义为，一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束，饥饿的情况不
易演示，讲读写锁时会涉及饥饿问题
下面我讲一下我遇到的一个线程饥饿的例子，先来看看使用顺序加锁的方式解决之前的死锁问题
在这里插入图片描述

顺序加锁的解决方案
在这里插入图片描述

ReentrantLock

相对于 synchronized 它具备如下特点

  • 可中断
  • 可以设置超时时间
  • 可以设置为公平锁
  • 支持多个条件变量

与 synchronized 一样，都支持可重入
基本语法

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

可重入
可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡

可打断
一个线程在等待锁的过程中，可以被其他线程打断而提前结束等待

ReentrantLock lock = new ReentrantLock();
 Thread t1 = new Thread(() -> {
    log.debug("启动...");
 try {
 lock.lockInterruptibly();
    } 
catch (InterruptedException e) {
 e.printStackTrace();
 log.debug("等锁的过程中被打断");
 return;
    }
 try {
 log.debug("获得了锁");
    } 
finally {
 lock.unlock();
    }
 }, "t1");
 lock.lock();
 log.debug("获得了锁");
 t1.start();
 try {
 sleep(1);
 t1.interrupt();
 log.debug("执行打断");
 } finally {
 lock.unlock();
 }

输出

18:02:40.520 [main] c.TestInterrupt - 获得了锁 
18:02:40.524 [t1] c.TestInterrupt - 启动... 
18:02:41.530 [main] c.TestInterrupt - 执行打断 
java.lang.InterruptedException 
at 
java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchr
 onizer.java:898) 
at 
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchron
 izer.java:1222) 
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335) 
at cn.onenewcode.n4.reentrant.TestInterrupt.lambda$main$0(TestInterrupt.java:17) 
at java.lang.Thread.run(Thread.java:748) 
18:02:41.532 [t1] c.TestInterrupt - 等锁的过程中被打断

锁超时
如果某个线程在规定的时间内无法获取到锁，就会超时放弃.可以一定限度防止死锁。

ReentrantLock lock = new ReentrantLock();
 Thread t1 = new Thread(() -> {
 log.debug("启动...");
 try {
 if (!lock.tryLock(1, TimeUnit.SECONDS)) {
 log.debug("获取等待 1s 后失败，返回");
 return;
        }
    } 
catch (InterruptedException e) {
 e.printStackTrace();
    }
 try {
 log.debug("获得了锁");
    } 
finally {
 lock.unlock();
    }
 }, "t1");
 lock.lock();
 log.debug("获得了锁");
 t1.start();
 try {
 sleep(2);
 } finally {
 lock.unlock();
 }

输出

18:19:40.537 [main] c.TestTimeout - 获得了锁 
18:19:40.544 [t1] c.TestTimeout - 启动... 
18:19:41.547 [t1] c.TestTimeout - 获取等待 1s 后失败，返回

不公平锁
表示获取锁的抢占机制，是随机获取锁的，和公平锁不一样的就是先来的不一定能拿到锁， 有可能一直拿不到锁，所以结果不公平。

ReentrantLock 默认是不公平的

ReentrantLock lock = new ReentrantLock(false);
 lock.lock();
 for (int i = 0; i < 500; i++) {
 new Thread(() -> {
 lock.lock();
 try {
 System.out.println(Thread.currentThread().getName() + " running...");
        } 
finally {
 lock.unlock();
        }
    }, "t" + i).start();
} 
 // 1s 之后去争抢锁
Thread.sleep(1000);
 new Thread(() -> {
 System.out.println(Thread.currentThread().getName() + " start...");
 lock.lock();
 try {
 System.out.println(Thread.currentThread().getName() + " running...");
    } 
    finally {
    lock.unlock();
    }
 }, "强行插入").start();
 lock.unlock();

强行插入，有机会在中间输出

t39 running... 
t40 running... 
t41 running... 
t42 running... 
t43 running... 
强行插入 start... 
强行插入 running... 
t44 running... 
t45 running... 
t46 running... 
t47 running... 
t49 running...

条件变量
synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待
ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比

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

使用要点：

  • await 前需要获得锁
  • await 执行后，会释放锁，进入 conditionObject 等待
  • await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
  • 竞争 lock 锁成功后，从 await 后继续执行
static ReentrantLock lock = new ReentrantLock();
 static Condition waitCigaretteQueue = lock.newCondition();
 static Condition waitbreakfastQueue = lock.newCondition();
 static volatile boolean hasCigrette = false;
 static volatile boolean hasBreakfast = false;
 public static void main(String[] args) {
 new Thread(() -> {
 try {
 lock.lock();
 while (!hasCigrette) {
    try {
 waitCigaretteQueue.await();
                } 
catch (InterruptedException e) {
 e.printStackTrace();
                }
            }
 log.debug("等到了它的烟");
        } 
finally {
 lock.unlock();
        }
    }).start();
 new Thread(() -> {
 try {
 lock.lock();
 while (!hasBreakfast) {
 try {
 waitbreakfastQueue.await();
                } 
catch (InterruptedException e) {
 e.printStackTrace();
                }
            }
 log.debug("等到了它的早餐");
        } 
finally {
 lock.unlock();
        }
    }).start();
 sleep(1);
 sendBreakfast();
 sleep(1);
 sendCigarette();
 }
 private static void sendCigarette() {
 lock.lock();
 try {
 log.debug("送烟来了");
 hasCigrette = true;
 waitCigaretteQueue.signal();
    } 
finally {
 lock.unlock();
    }
 }
 private static void sendBreakfast() {
 lock.lock();
 try {
 log.debug("送早餐来了");
 hasBreakfast = true;
 waitbreakfastQueue.signal();
    } 
finally {
 lock.unlock();
    }
 }

输出

18:52:27.680 [main] c.TestCondition - 送早餐来了 
18:52:27.682 [Thread-1] c.TestCondition - 等到了它的早餐 
18:52:28.683 [main] c.TestCondition - 送烟来了 
18:52:28.683 [Thread-0] c.TestCondition - 等到了它的烟

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/261451.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Windows 11 系统下JDK17的下载与配置

Windows 11 系统下JDK17的下载与配置

一般地&#xff0c;在做Java项目的时候&#xff0c;我一般喜欢用 Idea 软件来写代码&#xff0c;idea是代码编辑器&#xff0c;JDK是用来翻译写好的代码&#xff0c;两者缺一不可&#xff01;&#xff01;&#xff01; 下面我就来讲一下如何进行JDK17的下载与配置 JDK17的下载…
阅读更多...
鸿蒙ArkTS语言介绍与TS基础语法

鸿蒙ArkTS语言介绍与TS基础语法

1、ArkTS介绍 ArkTS是HarmonyOS主力应用开发语言&#xff0c;它在TS基础上&#xff0c;匹配ArkUI框架&#xff0c;扩展了声明式UI、状态管理等响应的能力&#xff0c;让开发者以更简洁、更自然的方式开发跨端应用。 JS 是一种属于网络的高级脚本语言&#xff0c;已经被广泛用…
阅读更多...
联盟 | Shoplazza X HelpLook，AI技术助推商业效能增长

联盟 | Shoplazza X HelpLook，AI技术助推商业效能增长

随着人工智能&#xff08;AI&#xff09;技术的快速发展&#xff0c;其在各个领域的影响力日益增强。特别是近几年&#xff0c;无论是独立站还是电商平台&#xff0c;都在积极探索利用AI来分析数据以及提升运营效率的方式。 在这场AI技术的浪潮中&#xff0c;Shoplazza 与 Hel…
阅读更多...
Jmeter关联操作

Jmeter关联操作

1.首先右键添加一个线程选择线程组,命名为线程组-1&#xff0c;添加取样器选择HTTP请求--城市天气 2.线程组-1右键&#xff0c;添加取样器选择后置处理器中的JSON提取器 3.线程组-1右键,添加取样器选择后置处理器中的BeanShell 后置处理程序(必须平级) 4.首先右键添加一个线程选…
阅读更多...
JVM启动流程(JDK8)

JVM启动流程(JDK8)

JVM启动流程(JDK8) JVM的启动入口是位于jdk/src/share/bin/java.c的JLI_Launch函数,其定义如下: int JLI_Launch(int argc, char ** argv, /* main argc, argc */int jargc, const char** jargv, /* java args */int appclassc, const char** appclass…
阅读更多...
贵金属入门知识有哪些?

贵金属入门知识有哪些?

贵金属作为国际知名的理财产品之一&#xff0c;市场人气居高不下&#xff0c;当前由于社会上的不确定分享增加&#xff0c;出于保值避险需求的推动&#xff0c;贵金属迎来了新一波发展高峰。对于刚刚接触贵金属市场的交易者来说&#xff0c;了解贵金属入门知识&#xff0c;做好…
阅读更多...
安卓开发学习---kotlin版---笔记（三）

安卓开发学习---kotlin版---笔记（三）

网络 安卓主页的网络框架&#xff1a;OkHttp 在OkHttp的基础上进行封装的&#xff1a;Retrofit框架&#xff0c;更常使用 OkHttp学习 在使用网络请求的时候&#xff0c;先添加网络访问权限&#xff1a; <uses-permission android:name"android.permission.INTERNET&…
阅读更多...
vue2 组件传递数据

vue2 组件传递数据

向子组件传递数据通过Props 1.创建子组件 详细步骤&#xff1a; 1.在components创建子组件 2.等父组件接受到参数后通过Props来接受父组件传递过来的数据 <template><div id"app"><h2>title:{{ title }}</h2><p>tips:{{ tips }}<…
阅读更多...
【力扣】148.排序链表

【力扣】148.排序链表

148.排序链表 怎么说&#xff0c;这道题看上去挺简单的&#xff0c;但是要搞清楚的知识点那还真不少&#xff0c;刷题好痛苦&#xff0c;但是要刷&#xff01;嘿嘿~ 首先&#xff0c;要搞懂归并排序&#xff0c;然后是递归。这道题我刚开始想的是递归&#xff0c;但是题友说时…
阅读更多...
2023/12/21作业

2023/12/21作业

思维导图 代码 .text .global _start _start: 灯1 gpio时钟使能 [4]->1 0x5000A28 LDR R0,0x50000A28 指定寄存器地址 LDR R1,[R0]将寄存器取出放到R1 ORR R1,R1,#(0x1<<4)将第四位设置为1 STR R1,[R0]读取R0寄存器到R1 PE…
阅读更多...
【开源软件】最好的开源软件-2023-第二名: Podman

【开源软件】最好的开源软件-2023-第二名: Podman

自我介绍 做一个简单介绍&#xff0c;酒架年近48 &#xff0c;有20多年IT工作经历&#xff0c;目前在一家500强做企业架构&#xff0e;因为工作需要&#xff0c;另外也因为兴趣涉猎比较广&#xff0c;为了自己学习建立了三个博客&#xff0c;分别是【全球IT瞭望】&#xff0c;【…
阅读更多...
vue3 在vite.config中无法使用import.meta.env.*的解决办法

vue3 在vite.config中无法使用import.meta.env.*的解决办法

第一种,优先使用第一种方法,其中参数mode就是自定义--mode的值,如果没写,就是production或development import { loadEnv } from vite export default ({ mode }) > {return defineConfig({plugins: [vue()],base:loadEnv(mode, process.cwd()).VITE_APP_NAME}) } 第二种 …
阅读更多...
鸿蒙开发基本概念

鸿蒙开发基本概念

1、开发准备 1.1、UI框架 HarmonyOS提供了一套UI开发框架&#xff0c;即方舟开发框架&#xff08;ArkUI框架&#xff09;。方舟开发框架可为开发者提供应用UI开发所必需的能力&#xff0c;比如多种组件、布局计算、动画能力、UI交互、绘制等。 方舟开发框架针对不同目的和技术…
阅读更多...
◢Django md5加密与中间件middleware

◢Django md5加密与中间件middleware

utils文件夹是重新建立的&#xff08;与migrations同级&#xff09;&#xff0c;该文件夹下主要存放工具&#xff0c;就像static文件夹下只存放静态文件一样 加密 在utils文件夹下建立encrypt.py文件 from django.conf import settings import hashlib def md5(data_string)…
阅读更多...
一个正则快速找到在ES中使用profile的时产生慢查询的分片

一个正则快速找到在ES中使用profile的时产生慢查询的分片

在es中使用profile分析慢查询的时候&#xff0c;往往因为分片过多&#xff0c;或者因为查询条件太复杂&#xff0c;分析的结果几十万行。在kibana上点半天&#xff0c;也找不到一个耗时长的分片。 kibana上可以通过正则来匹配。其实我们只需要匹配到耗时大于10秒的请求。 检索语…
阅读更多...
yolo-nas无人机高空红外热数据小目标检测（教程+代码）

yolo-nas无人机高空红外热数据小目标检测（教程+代码）

前言 YOLO-NAS是目前最新的YOLO目标检测模型。从一开始&#xff0c;它就在准确性方面击败了所有其他 YOLO 模型。与之前的 YOLO 模型相比&#xff0c;预训练的 YOLO-NAS 模型能够以更高的准确度检测更多目标。但是我们如何在自定义数据集上训练 YOLO NAS&#xff1f; 这将是我…
阅读更多...
多媒体信息化建设，动态数据中心，深入理解分布式系统

多媒体信息化建设，动态数据中心，深入理解分布式系统

目录 一、前言二、双活数据中心三、数据备份方式四、设计双活数据中心需要考虑的问题1、延迟和稳定性2、Quorum/ Tie-Breaker3、工作负载 五、动态数据中心六、深入理解分布式系统1、内容介绍2、作者简介 大家好&#xff0c;我是哪吒。 文末送5本《深入理解分布式系统》 一、…
阅读更多...
CentOS：Docker容器中安装vim

CentOS：Docker容器中安装vim

在使用docker容器时&#xff0c;里边没有安装vim时&#xff0c;敲vim命令时提示说&#xff1a;vim: command not found 这个时候就须要安装vim&#xff0c;安装命令&#xff1a; apt-get install vim 出现以下错误&#xff1a; 解决方法&#xff1a; apt-get update 这个命令的…
阅读更多...
LabVIEW的六轴工业机器人运动控制系统

LabVIEW的六轴工业机器人运动控制系统

LabVIEW开发六轴工业机器人运动控制系统 本项目开发了一个高效的工业机器人控制系统&#xff0c;重点关注于运动学算法和轨迹规划算法的实现和测试。LabVIEW作为一个关键技术&#xff0c;在项目中扮演了核心角色。 系统研究与算法开发&#xff1a;首先&#xff0c;项目围绕机…
阅读更多...
棱镜七彩获工业和信息化部电子第五研究所感谢信

棱镜七彩获工业和信息化部电子第五研究所感谢信

近日&#xff0c;工业和信息化部电子第五研究所&#xff08;以下简称“工信部电子五所”&#xff09;发来一封感谢信&#xff0c;对棱镜七彩在系统研发及运维保障工作中做出的贡献表示感谢。 图 工业和信息化部电子第五研究所感谢信 服务保障平台和赛宝优选平台应用解决方案征…
阅读更多...
最新文章

Copyright @ 2022~2023