Java Web 实战 13 - 多线程进阶之 synchronized 原理以及 JUC 问题

news/2024/10/31 9:29:12/

文章目录

  • 一 . synchronized 原理
    • 1.1 synchronized 使用的锁策略
    • 1.2 synchronized 是怎样自适应的? (锁膨胀 / 升级 的过程)
    • 1.3 synchronized 其他的优化操作
      • 锁消除
      • 锁粗化
    • 1.4 常见面试题
  • 二 . JUC (java.util.concurrent)
    • 2.1 Callable 接口
    • 2.2 ReentrantLock
    • 2.3 原子类
    • 2.4 线程池
      • ExecutorService 和 Executors

大家好 , 这篇文章给大家分享多线程中 synchronized 的原理以及 JUC 相关问题
注意这块的 synchronized 是小写的 , 一定要注意拼写
推荐大家跳转到 此链接 查看效果更佳~
上一篇文章的链接我也给大家贴到这里了
点击即可跳转到文章专栏~
在这里插入图片描述

一 . synchronized 原理

注意这块的 synchronized 是小写的 , 一定要注意拼写

1.1 synchronized 使用的锁策略

  1. 既是悲观锁 , 也是乐观锁 (自适应锁)
  2. 既是轻量级锁 , 也是重量级锁 (自适应锁)
  3. 轻量级锁部分基于自旋锁实现 , 重量级锁部分基于挂起等待锁来实现
  4. 不是读写锁
  5. 是非公平锁
  6. 是可重入锁

1.2 synchronized 是怎样自适应的? (锁膨胀 / 升级 的过程)

synchronized 在加锁的时候要经历几个阶段 :

  1. 无锁 (没加锁)
  2. 偏向锁 (刚开始加锁 , 未产生竞争的时候)
  3. 轻量级锁 (产生锁竞争了)
  4. 重量级锁 (锁竞争的更激烈了)

其中 , 我们再分析一下什么是偏向锁
偏向锁 , 不是"真正加锁" , 只是用个标记表示 “这个锁是我的了” , 在遇到其他线程来竞争锁之前 , 都始终保持这个状态 .
直到真的有人来竞争了,此时才真的加锁
这个过程类似于单例模式中的"懒汉模式" , 必要的时候再加锁 , 节省开销

举个栗子 :
我是一个漂亮的妹子 , 遇到了一个小哥哥 , 对他各个方面都很满意 , 我们的感情就很快升温
但是我就不和他确定关系 , 造成若即若离的感觉 , 这样的话后面如果我腻歪了 , 随时伸腿就踹了 , 成本很低
这就是偏向锁状态

突然 , 我又发现另外一个妹子也在接近小哥哥 , 这个时候我趁着他们俩刚认识 , 我就赶紧和小哥哥确立男女朋友关系 , 并且发朋友圈官宣 , 另外的这个妹子就上一边等着去
这就是偏向锁在遇到锁竞争的时候 , 再真正进行加锁

如果没有额外的妹子(线程)过来竞争 , 从始至终都是在偏向锁的状态 , 也就省去了加锁以及解锁的开销了 , 这就更加的轻量

1.3 synchronized 其他的优化操作

锁消除

锁消除.编译器自动判定 , 如果认为这个代码没必要加锁 , 就不加了 .
这个操作不是所有情况下都会触发 , 大部分情况下不能触发
比如 :

StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");

此处的这几个 append 方法 , 内部都是带有 synchronized 的
如果上述代码都是在同一个线程中运行的 , 此时就没必要再去加锁了
JVM 就悄悄地把锁去掉了

锁粗化

先了解锁的粒度 : synchronized 包含的代码范围是大还是小 , 范围越大 , 粒度越粗 ; 范围越小 , 粒度越细
锁的粒度细了 , 能够更好的提高线程的并发 , 但会也会增加 “加锁解锁” 的次数
image.png
image.png

1.4 常见面试题

  1. 能够理解 synchronized 基本执行过程 , 理解锁对象 , 理解锁竞争
  2. 能够知道 synchronized 的基本策略
  3. 能够理解 synchronized 内部的一些锁优化的过程 ( 锁升级 , 锁消除 , 锁粗化 )
  4. 什么是偏向锁

二 . JUC (java.util.concurrent)

concurrent 中文叫做并发
java.util.concurrent 这个包里就存放了很多和多线程开发相关的类

2.1 Callable 接口

和我们之前学习过得 Runnable 非常类似 , 都是可以在创建线程的时候 , 来指定一个 “具体的任务”
而 Callable 指定的任务是带有返回值的 , Runnable 是不带返回值的
Callable 里面会提供一个 call 方法 , call 方法是带有返回值的 , 我们可以借助它很容易的获得到任务的执行结果

举个栗子 : 创建线程计算 1 + 2 + 3 + … + 1000, 不使用 Callable 版本

static class Result {public int sum = 0;public Object lock = new Object();
}public static void main(String[] args) throws InterruptedException {Result result = new Result();// 创建一个线程去计算 1~100 之间的值// 但是我们通过 run 方法没办法返回值// 就需要把结果写入到 Result 类当中的 sum Thread t = new Thread() {@Overridepublic void run() {int sum = 0;for (int i = 1; i <= 1000; i++) {sum += i;}// 赋值操作需要加锁synchronized (result.lock) {result.sum = sum;result.lock.notify();}}};t.start();// 在主线程这里,再去针对 result 结果进行等待// 上面的 result 结果计算好之后,上面的 notify 就会唤醒下面的 wait// 打印 sum 的值synchronized (result.lock) {while (result.sum == 0) {result.lock.wait();}System.out.println(result.sum);}
}

上述代码需要一个辅助类 Result , 还需要使用一系列的加锁和 wait notify 操作 , 代码复杂 , 容易出错 .
我们可以使用 Callable 接口

import java.util.concurrent.Callable;public class Demo28 {public static void main(String[] args) {// 创建 Callable 接口,它是带有泛型参数的// 这个泛型参数实际就是 call 方法的返回值// new 一个匿名内部类Callable<Integer> callable = new Callable<Integer>() {// 这里的 Object 要改成 Integer@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i <= 1000; i++) {sum += i;}return sum;}};}
}

接下来 , 我们就可以新建线程执行这个任务了
image.png

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class Demo28 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建 Callable 接口,它是带有泛型参数的// 这个泛型参数实际就是 call 方法的返回值// new 一个匿名内部类Callable<Integer> callable = new Callable<Integer>() {// 这里的 Object 要改成 Integer@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i <= 1000; i++) {sum += i;}return sum;}};// 套上一层,目的是为了获取到后续的结果FutureTask<Integer> task = new FutureTask<>(callable);Thread t = new Thread(task);t.start();// 在线程 t 执行结束之前,get 会阻塞等待,直到 t 执行完了,结果算完了// get 才能返回.返回值就是 call 方法 return 的内容System.out.println(task.get());}
}

这里的 FutureTask 就好比 :
我们去餐馆吃饭 , 人很多的时候 , 老板会给你个小票 , 后续就可以凭小票来取餐


到目前为止 , 我们已经学习过好几种创建线程的方式了

  1. 继承 Thread
  2. 使用 Runnable
  3. 使用 lambda
  4. 使用 Callable
  5. 使用线程池

2.2 ReentrantLock

ReentrantLock 代表可重入锁

synchronized 已经是可重入锁了 , 为什么还要再弄一个 ReentrantLock 呢 ?

  1. synchronized 是单纯的关键字 , 以代码块为单位进行加锁解锁 .

ReentrantLock则是一个类 , 提供 lock 方法加锁 , unlock 方法解锁

import java.util.concurrent.locks.ReentrantLock;public class Demo29 {public static void main(String[] args) {ReentrantLock locker = new ReentrantLock();// 加锁locker.lock();// 其他代码逻辑// 解锁locker.unlock();}
}

但这种方式还存在一些问题
假如中间的其他代码逻辑出现了问题 , 抛出了异常 , 后面的 unlock() 就执行不到了
所以我们一般把加锁解锁操作放到 try catch finally 中

import java.util.concurrent.locks.ReentrantLock;public class Demo29 {public static void main(String[] args) {ReentrantLock locker = new ReentrantLock();try {// 加锁locker.lock();// 其他代码逻辑} finally {// 解锁locker.unlock();}}
}
  1. ReentrantLock 会提供一个"公平锁"版本 , 在构造实例的时候 , 可以通过构造方法指定一个参数 , 切换到公平锁模式

ReentrantLock locker = new ReentrantLock(true);
synchronized 只是一个非公平锁

  1. ReentrantLock 还提供了一个特殊的加锁操作 : tryLock()

默认的 lock 是加锁失败 , 就阻塞
而 tryLock 加锁失败 , 则不阻塞 , 直接往下执行 , 并且返回 false
除了立即失败之外 , tryLock 还能设定一定的等待时间 (等一会再失败)

  1. ReentrantLock 提供了更强大的 等待/唤醒 机制

synchronized 搭配的是 Object.wait / notify , 唤醒的时候 , 随机唤醒其中一个
ReentrantLock 搭配了 Condition 类来实现等待唤醒 , 可以做到能随机唤醒一个 , 也能指定线程唤醒

大部分情况下 , 使用锁还是 synchronized 为主 .
特殊场景下 , 才使用 ReentrantLock

2.3 原子类

原子类内部用的是 CAS 实现,所以性能要比加锁实现 i++ 高很多
我们常用的是 AtomicInteger
他的常用方法有

addAndGet(int delta);   i += delta;
decrementAndGet(); 		--i;
getAndDecrement(); 		i--;
incrementAndGet(); 		++i;
getAndIncrement(); 		i++;

2.4 线程池

虽然创建销毁线程比创建销毁进程更轻量 , 但是在频繁创建销毁线程的时候还是会比较低效.
线程池就是为了解决这个问题 . 如果某个线程不再使用了 , 并不是真正把线程释放 , 而是放到一个 "池子"中 , 下次如果需要用到线程就直接从池子中取 , 不必通过系统来创建了.

ExecutorService 和 Executors

ExecutorService 是一个线程实例 , Executors 是一个工厂类

Executors 创建线程池的几种方式

  • newFixedThreadPool : 创建固定线程数的线程池
  • newCachedThreadPool : 创建线程数目动态增长的线程池.
  • newSingleThreadExecutor : 创建只包含单个线程的线程池.
  • newScheduledThreadPool : 设定 延迟时间后执行命令 , 或者定期执行命令 . 是进阶版的 Timer.

Executors 本质上是 ThreadPoolExecutor 类的封装 , 这个类是标准库中最核心的线池类
打开我们的 Java 文档
image.png
我们来看第四个构造方法
image.png
实际工作中 , 一般建议大家 , 使用线程池的时候 , 尽量还是用 ThreadPoolExecutor 复杂版本的 , 这里的参数都显式的手动传参 , 这样就可以更好的掌控代码

当我们使用线程池的时候 , 线程数目设置成多少合适 ?
只要你回答出具体的数字 , 一定都是错的 .
不同的场景 , 不同的程序 , 不同的主机配置 , 都会有差异
面试中我们回答不了具体设置几个线程 , 但是可以回答 : 找到合适线程数的方法 -> 压测(性能测试)
针对当前的程序进行性能测试 , 分别设置不同的线程数目 , 分别进行测试
在测试过程中 , 会记录程序的时间、CPU占用、内存占用…
根据压测结果 , 来选择咱们觉得最适合当前场景的数目


关于 JUC , 我们后续还会再增加一些内容 , 大家敬请期待~
如果对你有帮助的话 , 请一键三连嗷~
在这里插入图片描述


http://www.ppmy.cn/news/32491.html

相关文章

如何绕开运营商的 QoS 限制

运营商针对 UDP 进行限制&#xff0c;这是 QUIC 以及类似 UDP-Based 协议的推广阻力之一&#xff0c;上了线很多问题&#xff0c;丢包&#xff0c;慢等的问题严重增加运维&#xff0c;运营成本。 按照运营商五元组 QoS 这种简单粗暴不惹事的原则&#xff0c;只要换一个端口就可…

python 正则使用详解

python 正则使用详解什么是正则在 python 中使用正则一些正则的定义python 正则的方法match 从字符串开头匹配正则返回的结果分析&#xff08;重要&#xff09;fullmatch 严格匹配整个字符串search 任意位置开始匹配sub 替换匹配内容subn 以元组方式返回替换结果split 正则切割…

蓝桥杯刷题冲刺 | 倒计时24天

作者&#xff1a;指针不指南吗 专栏&#xff1a;蓝桥杯倒计时冲刺 &#x1f43e;马上就要蓝桥杯了&#xff0c;最后的这几天尤为重要&#xff0c;不可懈怠哦&#x1f43e; 文章目录1.修剪灌木2.统计子矩阵1.修剪灌木 题目 链接&#xff1a; 修剪灌木 - 蓝桥云课 (lanqiao.cn) 找…

震撼,支持多模态模型的ChatGPT 4.0发布了

最近几个月&#xff0c;互联网和科技圈几乎ChatGPT刷屏了&#xff0c;各种关于ChatGPT的概念和应用的帖子也是围绕在周围。当去年年底ChatGPT发布的那几天&#xff0c;ChatGPT确实震撼到了所有人&#xff0c;原来AI还可以这么玩&#xff0c;并且对国内的那些所谓的人工智能公司…

Kubernetes详细安装

By&#xff1a;雪月三十 参考&#xff1a; https://blog.csdn.net/qq_43580215/article/details/125153959 https://juejin.cn/post/6844903943051411469 https://mp.weixin.qq.com/s?__bizMzI0MDQ4MTM5NQ&mid2247502359&idx1&sn8c16100c9731359b9864403183f44233…

C语言/动态通讯录

本文使用了malloc、realloc、calloc等和内存开辟有关的函数。 文章目录 前言 二、头文件 三、主界面 四、通讯录功能函数 1.全代码 2.增加联系人 3.删除联系人 4.查找联系人 5.修改联系人 6.展示联系人 7.清空联系人 8.退出通讯录 总结 前言 为了使用通讯录时&#xff0c;可以…

哈佛与冯诺依曼结构

1. 下图是典型的冯诺依曼结构 2. CPU分为三部分&#xff1a;ALU运算单元&#xff0c;CU控制单元&#xff0c;寄存器组。 3. 分析51单片机为何能使用汇编进行编程 51指令集&#xff08;Instruction Set&#xff09;是单片机CPU能够执行的所有指令的集合。在编写51单片机程序时&a…

线程池的使用:如何写出高效的多线程程序?

目录1.线程池的使用2.编写高效的多线程程序Java提供了Executor框架来支持线程池的实现&#xff0c;通过Executor框架&#xff0c;可以快速地创建和管理线程池&#xff0c;从而更加方便地编写多线程程序。 1.线程池的使用 在使用线程池时&#xff0c;需要注意以下几点&#xff…