＜JavaEE＞ 什么是线程安全？产生线程不安全的原因和处理方式

目录

一、线程安全的概念

二、线程不安全经典示例

三、线程不安全的原因和处理方式

3.1 线程的随机调度和抢占式执行

3.2 修改共享数据

3.3 关键代码或指令不是“原子”的

3.4 内存可见性和指令重排序

四、Java标准库自带的线程安全类

---

一、线程安全的概念

线程安全是指：某段代码无论是在单线程还是多线程的环境下执行，结果都是正确的或符合心理预期的。

通常情况下，如果一段代码在单线程环境下执行和在多线程环境下执行的结果不一致，那么就很可能存在线程安全的问题，这个情况就称为“线程不安全”。

线程安全问题是多线程编程的重点！

---

二、线程不安全经典示例

class AddTest{
    public static  int count = 0;
    public void add(){
        count++;
    }
}
public class Synchronized_Demo0 {
    public static void main(String[] args) throws InterruptedException {
        //创建一个AddTest实例；
        AddTest test1 = new AddTest();

        //两个循环调用add方法进行count++的线程；
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                test1.add();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                test1.add();
            }
        });

        //启动线程；
        t1.start();
        t2.start();

        //阻塞main线程；
        t1.join();
        t2.join();

        //打印count；
        System.out.println("count = ："+AddTest.count);
    }
}

//第一次运行结果：
count = 8061
//第二次运行结果：
count = 7269
//第三次运行结果：
count = 9792

在单线程环境下，两个5000次循环的count++，得到的结果应该是count = 10000。

上述代码在多线程的环境下，得到的结果却是count = 8061。

而且，每次运行得到的结果都会不同。

这就出现了线程安全问题。

---

三、线程不安全的原因和处理方式

线程不安全的五个原因

1）线程的随机调度和抢占式执行(根本原因)。

2）修改共享数据。

3）关键代码或指令不是“原子”的(直接原因)。

4）内存可见性。

5）指令重排序。

3.1 线程的随机调度和抢占式执行

原因和处理方式：

原因	操作系统上的线程是“随机调度”和“抢占式执行”的，这是产生线程安全问题的根本原因。
处理方式	这个原因是由操作系统本身决定的，无法改变。

3.2 修改共享数据

前置知识点：

上述代码中，“count++；”这一句代码实际上是由三条系统指令完成的。包括以下三条指令：

load(读取)：从内存中读取数据；

add(运算)：进行数据运算；

save(写入)：将运算后的数据写入内存中；

根据下图进行分析：

在示例代码中，有多个线程在“同一时刻”，访问了同一变量(count)，这个变量就是一个“共享数据”。

通过以上分析，我们发现可以使用两个不同的变量自增，自增完成后再相加，可以解决这里的线程不安全问题。

原因和处理方式：

原因	多个线程修改同一个变量。
处理方式	这是一个与代码结果相关的问题，有时可以通过调整代码结构解决，但有时代码结构是无法调整的。

3.3 关键代码或指令不是“原子”的

根据下图进行分析：

原因和处理方式：

原因	代码中影响线程安全的关键代码或指令不是“原子”的。这是产生线程不安全的直接原因。
处理方式	使用 synchronized 关键字加锁，是代码或指令实现逻辑上的原子性，即当线程在执行这些代码或指令时，要么全部不执行，要么全部执行完毕后其他线程才能进入。
应该注意，这里的加锁并不是让代码或指令实现真正的原子性。 也就是说不是真的在执行加锁的代码或指令时不让线程被调度走，而是线程仍可以“暂时离开”。 但此时其他线程也不得进入这段被执行了“一半”的加锁代码或指令。 如上文所讲的，是“打包”为一个逻辑上的整体。

阅读指针 -> 《 synchronized 关键字 和 锁机制 》

＜JavaEE＞ synchronized关键字和锁机制 -- 锁的特点、锁的使用、锁竞争和死锁、死锁的解决方法-CSDN博客Java中加锁的方式有很多种，其中使用 synchronized 关键字进行加锁是最常用的。synchronized 是一种监视器锁（monitor lock）。是为了将多个操作“打包”为一个有“原子性”的操作。进行加锁的时候必须先准备好“锁对象”，锁对象可以是任何类型的实例。synchronized 的底层是使用操作系统的 mutex lock 实现的，本质上依然是调用系统的 API ，依靠 CPU 的特定指令完成加锁功能的。https://blog.csdn.net/zzy734437202/article/details/134742168

3.4 内存可见性和指令重排序

原因：	内存可见性指的是一个线程对共享数据的修改，能否即使被其他线程观测到。如果没有，那么其他线程则无法获得正确数据。
原因：	指令重排序是指在“保证程序执行逻辑不变”的情况下，改变指令的执行顺序，以提高编译器的运行效率。 指令重排序在单线程下非常有效，但在多线程下对于“保证程序执行逻辑不变”这一条件判断难度高，因此会出现因为指令重排序而导致的线程不安全。
处理方式：	以上的两个产生线程不安全的原因都来自于编译器优化，本意是通过调整指令执行顺序，提高程序效率，但在多线程环境下，会导致线程不安全。 为应对这种情况，Java提供了 volatile 关键字，用于强制关闭编译器优化。 volatile 关键字的两大核心功能就是保证内存可见性和进制指令重排序。

阅读指针 -> 《 volatile 关键字的 功能 和 使用 》

＜JavaEE＞ volatile关键字 -- 保证内存可见性、禁止指令重排序-CSDN博客简单介绍什么是内存可见性和指令重排序。volatile关键字可以将这两种编译器优化强制关闭。https://blog.csdn.net/zzy734437202/article/details/134757070

---

四、Java标准库自带的线程安全类

Java标准库中，有很多类虽然涉及多线程修改共享数据，但又没有加锁措施，因此他们都是线程不安全的。
线程不安全的类：	ArrayList
	LinkedList
	HashMap
	TreeMap
	HashSet
	TreeSet
	StringBuiler

当然，也有一些线程安全的类。 以下的类通过锁机制使得在多线程下，产生线程安全问题的概率大大降低了。
线程安全的类：	Vector
	HashTable
	ConcurrentHashMap
	StringBuffer
可以看到有一些类被添加了删除线。是的，根据官方文档，推荐不再使用这几个类，因为它们即将被标准库弃用。
String字符串类比较特殊，因为String本身就是不可变的，因此它就是线程安全的。

---

阅读指针 -> 《 多线程编程中的常用方法 wait 和 notify 》

链接生成中......