前言
在本栏的前面的内容中，我们介绍了线程的创建、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种的情况举下例子：
上图中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）的下一节我们将继续介绍线程。
