专栏简介: JavaEE从入门到进阶
题目来源: leetcode,牛客,剑指offer.
创作目标: 记录学习JavaEE学习历程
希望在提升自己的同时,帮助他人,,与大家一起共同进步,互相成长.
学历代表过去,能力代表现在,学习能力代表未来!
目录
1. 线程状态
1.1 观察线程的所有状态
1.2 线程的状态和状态转移的意义
2.线程安全
2.1 线程安全的概念:
2.2 线程安全问题的原因
2.3 从原子性角度解决线程安全问题
synchronized 关键字使用方法:
1. 线程状态
1.1 观察线程的所有状态
线程的状态 Thread.State 是一个枚举类型. 可通过遍历查看其所有类型.
public static void main(String[] args) {
for (Thread.State state : Thread.State.values()){
System.out.println(state);
}
}
- 1. NEW: 创建了 Thread 对象 , 但还没有调用 start (内核中还没有创建对应的PCB)
- 2. TERMINATED: 表示内核中的 PCB 已执行完毕 , 但Thread对象还在.
- 3. RUNNABLE: 可运行的. 分为两种情况 a).正在CPU上执行的 b).在就绪队列中 , 随时可以去CPU上执行. 一般不做区分.
- 4. WAITING: 表示线程 PCB 正在阻塞队列中
- 5. TIMED_WAITING: 表示线程 PCB 正在阻塞队列中
- 6. BLOCKED: 表示线程 PCB 正在阻塞队列中
1.2 线程的状态和状态转移的意义
通过下面代码来演示 , 相比于单线程 , 多线程效率的提升.
假设有两个变量 a 和变量 b , 现需要将两个变量各自自增100亿次.(典型的 CPU 密集型场景)
Tips: 编写多线程代码时 , 不能调用完 start 方法后就立即结束计时 , 还需调用 jion 方法等待 t1 和 t2 两个线程结束. 这就好比 main线程是裁判员 , t1 和 t2 是准备赛跑的运动员 , 裁判一声令下还没等运动员反应过来就立即结束计时 , 这显然是不合常理的.裁判需等待运动员跑过终点线再结束计时.
public static void main(String[] args) throws InterruptedException {
// serial();
concurrency();
}
/**
* 多线程执行
* @throws InterruptedException
*/
public static void concurrency() throws InterruptedException {
Thread t1 = new Thread(()->{
long a = 0;
for (long i = 0; i < 10000_0000_00L; i++) {
a++;
}
});
Thread t2 = new Thread(()->{
long b = 0;
for (long i = 0; i < 10000_0000_00L; i++) {
b++;
}
});
long startTime = System.currentTimeMillis();
t1.start();
t2.start();
t1.join();
t2.join();
long endTime = System.currentTimeMillis();
System.out.println("执行时间"+ (endTime-startTime)+"ms");
}
/**
* 单线程执行
*/
public static void serial(){
long a = 0;
long b = 0;
long startTime = System.currentTimeMillis();
for (long i = 0; i < 10000_0000_00L; i++) {
a++;
}
for (long i = 0; i < 10000_0000_00L; i++) {
b++;
}
long endTime = System.currentTimeMillis();
System.out.println("执行时间: "+(endTime-startTime)+"ms");
}
观察执行结果我们可以发现 , 相比于单线程执行 , 多线程执行可以节省大量时间 , 但并非我们认为的节省一半时间 , 这是因为多线程在调度时还会有额外的开销 , 而且不能保证多线程一定是在两个CPU上执行.
由此我们可以得出结论: 不是说使用多线程就一定能提高效率!!还需考虑以下两点:
- CPU是否是多核 (现在CPU基本都是多核)
- 当前核心是否空闲 (如果CPU的所有核心都已满载 , 此时启用再多的线程也无济于事)
2.线程安全
2.1 线程安全的概念:
线程不安全的主要原因是多线程的抢占式执行带来的随机性 , 原本在单线程中 , 代码按照固定的顺序执行 , 那么程序的执行结果就是固定的 , 如果有了多线程 , 代码执行顺序的可能性就从一种情况变成无数种情况!!只要有一种情况 , 程序执行结果不正确 , 就会视为线程不安全.
如果多线程环境下代码的运行结果符合我们的预期 , 即是在单线程环境下预期的结果 , 则说这个线程是线程安全的.
线程不安全示例:
创建两个线程分别对 count 自增5w次 , 按照预期执行结果应是的 count = 10w次.
class Counter{
public int count;
public void add(){
count++;
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
Counter counter = new Counter();
Thread t1 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
counter.add();
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
counter.add();
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("count = "+counter.count);
}
}多次运行观察结果与我们预期相差较大 , 明显出现了bug.
那么程序为什么会出现上述的bug呢?
count++ 操作本质上要分为三步:
- 1. 先把内存中的值 , 读取到CPU的寄存器中. load
- 2. 把CPU寄存器里的数值进行+1运算. add
- 3. 把得到的结果都写到内存中. save
如果两个线程并发执行count++ , 此时相当于两组 load add save 进行执行 , 此时不同的线程调度顺序就可能产生结果上的差异. 如下图所示 , 线程的调度顺序有无数种可能 , 但只有第一种执行顺序是安全的.
正确执行顺序: t1 线程先进行 load 操作 , 将count=0传入寄存器中 , 再进行 add 操作将寄存器中的值+1 , 最后执行 save 操作将寄存器中的值保存到内存中. t2 线程操作顺序与 t1 线程一致 , 最终计算结果为 2.
错误执行顺序: t1 和 t2 先后执行 load 操作 , 此时两个寄存器中 count=0.接着 t2 执行 add 操作将寄存器中的值+1 , 最后执行 save 操作 , 将count=1保存到内存中. 然后 t1 执行 add 和 save 操作 , 最后还是将count=1保存到内存中 , 此时我们发现经历了两次自增 , 结果还是1.造成该结果的原因是 t1 读取了 t2 还未提交的脏数据.(脏读)
2.2 线程安全问题的原因
1.[根本原因] 抢占式执行 , 随机调度.
多线程本身的特点 , 无能为力.
2.[代码结构] 修改共享数据
在上述不安全的多线程代码中 , 涉及到多个线程对 counter.count 变量进行修改 , 此时这个counter.count 就是一个多线程都能访问到的共享数据.
Tips: counter.count 这个变量就在堆上 , 因此可以被多个线程访问.
3.原子性
一条Java语句不一定是原子的 , 也不一定只是一条指令.
比如 我们刚才看到的 count++ 其实就是三步操作:
- 从存储把数据读到CPU寄存器
- 更新数据
- 把数据写回到CPU
如果一个线程正在进行操作 , 中途其他线程突然插进来 , 如果这个操作被打断了 , 结果很可能是错误的.这个问题的本质还是多线程的抢占式执行 , 如果线程不是"抢占"的 , 即使不是原子的也没有问题.因此解决这个线程安全问题 , 最主要的手段就是从原子性入手 , 把这个非原子的操作变成原子的 , 常见办法就是加锁.
4.内存可见性
可见性指 , 一个线程对共享变量值的修改 , 能够及时的被其他线程看到.后续会在volatile关键字专栏做更详细的讲解.
5.指令重排序(本质上是编译器优化出bug)
一段代码的编写是这样的:
1.去前台去U盘
2.去学习10min
3.去前台取快递
在单线程中执行时 , JVM 和 CPU 指令集 , 会对其进行优化 , 按照1->3->2 的方式执行 , 这样可以少跑一次柜台提高代码执行的效率 , 这种叫做指令重排序.编译器指令重排序的前提是"保持代码逻辑不会发生变化" , 在单线程的环境下代码执行逻辑可以很好的预测 , 但是在多线程的环境下 , 代码复杂度更高 , 编译器很难在编译时期就对代码的执行结果进行预测 , 因此激进的重排序可能导致优化后的逻辑与之前不等价.
2.3 从原子性角度解决线程安全问题
通过加锁操作把不是原子的操作变为"原子"的.因此我们可以使用 synchronized 关键字对线程加锁 , 如果两个线程同时尝试加锁 , 此时只有一个线程能成功 , 另一个线程只能阻塞等待(BLOCKED) , 一直阻塞到刚才的线程释放锁 , 另一个线程才能加锁成功.
lock 的阻塞就把刚才的 t2 的 load 推迟到 t1 的 save 之后 , 从而避免了脏读.加锁虽说是保证原子性 , 其实并不是让这三个操作一次性完成 , 也不是这三步操作过程中不执行调度 , 而是让其他也想执行的线程阻塞等待.(加锁的本质就是把并发变成串行)
打个比方就是 , 一个女生如果没有男朋友就是没有加锁的状态 , 其他男生都可以去追求她 , 一但有了男朋友 , 这个女生就加锁了 , 其他男生想追求只能等 , 这个女生和他男朋友分手相当于释放锁 , 释放锁之后其他男生才能去追求.
修改部分代码:
class Counter{
public int count;
public synchronized void add(){
count++;
}
}运行结果符合预期 , synchronized 关键字下篇文章会专门讲解 , 这里不展开赘述.
