前言
在本栏的前面的内容中,我们介绍了线程的创建、Thread 类及常见方法、线程的状态,今天我们来介绍一下关于线程的另一个重点知识——线程安全。
一、线程安全
基本概念:
线程安全的确切定义是复杂的,但我们可以这样认为:如果多线程环境下代码运行的结果是符合我们预期的,即在单线程环境应该的结果,则说这个程序是线程安全的。
我们给出一个具体例子,这个自加到10000的例子将会很好的体现线程安全:
static class Counter {
public int count = 0;
void increase() {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
-----------------------------------------------
输出结果:59970
}
那么问题来了,理想输出结果为100000,但实际结果为什么不符合呢?
二、线程不安全的原因
首先,让我们理解一下什么是原子性
2.1 什么是原子性
我们把一段代码想象成一个房间,每个线程就是要进入这个房间的人。如果没有任何机制保证,A进入房间之后,还没有出来;B 是不是也可以进入房间,打断 A 在房间里的隐私。这个就是不具备原子性的。
那我们应该如何解决这个问题呢?
是不是只要给房间加一把锁,A 进去就把门锁上,其他人是不是就进 不来了。这样就保证了这段代码的原子性了
一条 java 语句不一定是原子的,也不一定只是一条指令
比如刚才我们看到的 n++,其实是由三步操作组成的:
- 从内存把数据读到 CPU
- 进行数据更新
- 把数据写回到 CPU
- 不保证原子性会给多线程带来什么问题
如果一个线程正在对一个变量操作,中途其他线程插入进来了,如果这个操作被打断了,结果就可能是
错误的。这点也和线程的抢占式调度密切相关。如果线程不是 “抢占” 的,就算没有原子性,也问题不大。
2.2 上述代码错误的具体原因
count++ 这个操作,站在CPU的角度上,count++是由CPU通过三个指令完成的。
- load 把数据从内存, 读到 cpu 寄存器中;
- add把寄存器中的数据进行 +1;
- save 把寄存器中的数据,保存到内存中。
;如果是多个线程执行上述代码,由于线程之间的调度顺序是“随机”的,就会导致在有些调度顺序下,上述的逻辑就会出现问题。比如,我们简单选取4种的情况举下例子:
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/c7b0a6a967d6429b9f06edba2baaf050.png)
上图中1、2两种情况没有发生逻辑错误,因此不会发生错误,但是第三、四情况就会调度顺序随机,造成代码结果出现错误。
2.3 线程安全的具体原因
- 操作系统对于线程的调度是随机的;
- 多个线程同时修改同一个变量;
- 修改操作不是原子的;
- 内存可见性;
- 指令重排序。
三、Synchronized关键字
上述出现的线程不安全问题,通过加锁,就能解决上述问题,其中最常用的办法,就是使用synchronized 关键字。
synchronized 在使用的时候,要搭配一个 代码块{ } ;
在已经加锁的状态中,另一个线程尝试同样加这个锁,就会产生“锁冲突/锁竞争”,后一个线程就会阻塞等待-直等到前一个线程解锁为止。
让我们再次回到上面的那个例子,通过加锁便可以加锁线程安全的问题:
实例代码1:
/**
* @author Zhang
* @date 2024/5/515:43
* @Description:
*/
class Counter{
public int count;
// 1)直接修饰普通方法;
synchronized public void increase(){
count++;
}
//上面的写法是下面的简化版本
public void increase2(){
synchronized(this){
count++;
}
}
// 2)修饰静态方法;
synchronized public static void increase4(){
}
public static void increase5(){
synchronized(Counter.class){
}
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(()->{
for (int j = 0; j < 50000; j++) {
counter.increase();
}
});
t1.start();;
t2.start();
t1.join();
t2.join();
System.out.println("count:"+counter.count);
}
}
------------------------------------------------------
输出:100000
实例代码2:
public class Test1 {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
Object lock= new Object();
Thread t = new Thread(()->{
for (int i = 0; i < 50000; i++) {
synchronized (lock){
count++;
}
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 50000; i++) {
synchronized (lock){
count++;
}
}
});
//t、t2同时执行
t.start();
t2.start();
t.join();
t2.join();
//预期结果100000
System.out.println("count: "+count);
}
}
--------------------------------------------------------
输出:100000
总结
好啦!今天我们讲解了线程安全问题,以及为什么会出现线程安全、如何解决线程安全、synchronized关键字。在本栏(https://blog.csdn.net/2301_80653026/category_12660552.html?spm=1001.2014.3001.5482)的下一节我们将继续介绍线程。