文章目录
大家好 , 这篇文章给大家分享多线程中 synchronized 的原理以及 JUC 相关问题
注意这块的 synchronized 是小写的 , 一定要注意拼写
推荐大家跳转到 此链接 查看效果更佳~
上一篇文章的链接我也给大家贴到这里了
点击即可跳转到文章专栏~
一 . synchronized 原理
注意这块的 synchronized 是小写的 , 一定要注意拼写
1.1 synchronized 使用的锁策略
- 既是悲观锁 , 也是乐观锁 (自适应锁)
- 既是轻量级锁 , 也是重量级锁 (自适应锁)
- 轻量级锁部分基于自旋锁实现 , 重量级锁部分基于挂起等待锁来实现
- 不是读写锁
- 是非公平锁
- 是可重入锁
1.2 synchronized 是怎样自适应的? (锁膨胀 / 升级 的过程)
synchronized 在加锁的时候要经历几个阶段 :
- 无锁 (没加锁)
- 偏向锁 (刚开始加锁 , 未产生竞争的时候)
- 轻量级锁 (产生锁竞争了)
- 重量级锁 (锁竞争的更激烈了)
其中 , 我们再分析一下什么是偏向锁
偏向锁 , 不是"真正加锁" , 只是用个标记表示 “这个锁是我的了” , 在遇到其他线程来竞争锁之前 , 都始终保持这个状态 .
直到真的有人来竞争了，此时才真的加锁
这个过程类似于单例模式中的"懒汉模式" , 必要的时候再加锁 , 节省开销
举个栗子 :
我是一个漂亮的妹子 , 遇到了一个小哥哥 , 对他各个方面都很满意 , 我们的感情就很快升温
但是我就不和他确定关系 , 造成若即若离的感觉 , 这样的话后面如果我腻歪了 , 随时伸腿就踹了 , 成本很低
这就是偏向锁状态
突然 , 我又发现另外一个妹子也在接近小哥哥 , 这个时候我趁着他们俩刚认识 , 我就赶紧和小哥哥确立男女朋友关系 , 并且发朋友圈官宣 , 另外的这个妹子就上一边等着去
这就是偏向锁在遇到锁竞争的时候 , 再真正进行加锁
如果没有额外的妹子(线程)过来竞争 , 从始至终都是在偏向锁的状态 , 也就省去了加锁以及解锁的开销了 , 这就更加的轻量
1.3 synchronized 其他的优化操作
锁消除
锁消除.编译器自动判定 , 如果认为这个代码没必要加锁 , 就不加了 .
这个操作不是所有情况下都会触发 , 大部分情况下不能触发
比如 :
StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");
此处的这几个 append 方法 , 内部都是带有 synchronized 的
如果上述代码都是在同一个线程中运行的 , 此时就没必要再去加锁了
JVM 就悄悄地把锁去掉了
锁粗化
先了解锁的粒度 : synchronized 包含的代码范围是大还是小 , 范围越大 , 粒度越粗 ; 范围越小 , 粒度越细
锁的粒度细了 , 能够更好的提高线程的并发 , 但会也会增加 “加锁解锁” 的次数
1.4 常见面试题
- 能够理解 synchronized 基本执行过程 , 理解锁对象 , 理解锁竞争
- 能够知道 synchronized 的基本策略
- 能够理解 synchronized 内部的一些锁优化的过程 ( 锁升级 , 锁消除 , 锁粗化 )
- 什么是偏向锁
二 . 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() {
@Override
public 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
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 1000; i++) {
sum += i;
}
return sum;
}
};
}
}
接下来 , 我们就可以新建线程执行这个任务了
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
@Override
public 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 就好比 :
我们去餐馆吃饭 , 人很多的时候 , 老板会给你个小票 , 后续就可以凭小票来取餐
到目前为止 , 我们已经学习过好几种创建线程的方式了
- 继承 Thread
- 使用 Runnable
- 使用 lambda
- 使用 Callable
- 使用线程池
2.2 ReentrantLock
ReentrantLock 代表可重入锁
synchronized 已经是可重入锁了 , 为什么还要再弄一个 ReentrantLock 呢 ?
- 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();
}
}
}
- ReentrantLock 会提供一个"公平锁"版本 , 在构造实例的时候 , 可以通过构造方法指定一个参数 , 切换到公平锁模式
ReentrantLock locker = new ReentrantLock(true);
synchronized 只是一个非公平锁
- ReentrantLock 还提供了一个特殊的加锁操作 : tryLock()
默认的 lock 是加锁失败 , 就阻塞
而 tryLock 加锁失败 , 则不阻塞 , 直接往下执行 , 并且返回 false
除了立即失败之外 , tryLock 还能设定一定的等待时间 (等一会再失败)
- 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 文档
我们来看第四个构造方法
实际工作中 , 一般建议大家 , 使用线程池的时候 , 尽量还是用 ThreadPoolExecutor 复杂版本的 , 这里的参数都显式的手动传参 , 这样就可以更好的掌控代码
当我们使用线程池的时候 , 线程数目设置成多少合适 ?
只要你回答出具体的数字 , 一定都是错的 .
不同的场景 , 不同的程序 , 不同的主机配置 , 都会有差异
面试中我们回答不了具体设置几个线程 , 但是可以回答 : 找到合适线程数的方法 -> 压测(性能测试)
针对当前的程序进行性能测试 , 分别设置不同的线程数目 , 分别进行测试
在测试过程中 , 会记录程序的时间、CPU占用、内存占用…
根据压测结果 , 来选择咱们觉得最适合当前场景的数目
关于 JUC , 我们后续还会再增加一些内容 , 大家敬请期待~
如果对你有帮助的话 , 请一键三连嗷~
