线程安全问题的原因与解决方案总结

目录

一 什么是线程安全？

二 线程安全问题的实例 

三 线程安全问题的原因

1.多个线程修改共享数据 

2.抢占式执行

3.修改操作不是原子的

4.内存可见性问题

5.指令重排序 

四 解决方案

1.同步代码块 

2.同步方法 

3.加锁lock解决问题 

---

一 什么是线程安全？

线程安全是指一个代码段或方法能够在多线程环境下正确地工作，即当多个线程同时访问共享资源（如变量、数据结构等）时，不会导致数据不一致或其他异常行为。具体来说，如果一段代码在被多个线程并发执行时，能够保证程序状态的一致性，避免出现竞态条件、死锁、数据损坏等问题，那么这段代码就是线程安全的。

二 线程安全问题的实例 

public class Demo {// 定义一个静态变量 count，初始值为 0。// 静态变量属于类，所有实例共享同一个静态变量。private static int count = 0;public static void main(String[] args) throws InterruptedException {// 创建第一个线程 t1，使用 Lambda 表达式定义线程任务。Thread t1 = new Thread(() -> {// 在 t1 线程中执行一个循环，循环 10000 次。for (int i = 0; i < 10000; i++) {// 每次循环对静态变量 count 进行自增操作。count++;}});// 创建第二个线程 t2，同样使用 Lambda 表达式定义线程任务。Thread t2 = new Thread(() -> {// 在 t2 线程中执行一个循环，循环 10000 次。for (int i = 0; i < 10000; i++) {// 每次循环对静态变量 count 进行自增操作。count++;}});// 启动线程 t1，t1 开始执行。t1.start();// 启动线程 t2，t2 开始执行。t2.start();// 调用 t1.join()，主线程会等待 t1 执行完毕后再继续执行。t1.join();// 调用 t2.join()，主线程会等待 t2 执行完毕后再继续执行。t2.join();// 打印最终的 count 值。// 注意：由于 count++ 操作不是线程安全的，可能会出现竞争条件（Race Condition），// 导致最终的 count 值小于预期的 20000。System.out.println(count);}
}

运行结果： 

count++ 实际上是三个步骤的组合：读取 count 的值、将其加 1、再写回 count。由于这些操作不是原子性的，在多线程环境下可能会导致问题。例如，两个线程可能同时读取到 count 的旧值，各自加 1 后再写回，结果只会增加 1 而不是 2。因此，最终的 count 值可能小于预期的 20000。这就是多线程导致的线程安全问题。

三 线程安全问题的原因

1.多个线程修改共享数据 

当两个或更多的线程试图同时访问和修改同一个资源时，可能会导致竞态条件。例如，一个线程正在读取某个值的同时，另一个线程可能正在修改这个值，这会导致不可预测的结果。 

2.抢占式执行

3.修改操作不是原子的

原子性：指的是一个操作要么完全执行，要么完全不执行，中间状态对外不可见。

无论是在单核还是多核环境中，具有原子性的操作在同一时刻只能由一个线程完成，从而避免了多线程并发访问导致的数据不一致问题。

简单来说，如果一个操作在执行过程中不会被其他线程干扰，就可以认为它具有原子性。例如，在Java中，a=1这样的简单赋值操作（针对基本数据类型，除了long和double）通常被认为是原子性操作，而像a++或a+=1这样的复合操作则不是原子性的，因为它们涉及读取、修改和写入的多个步骤，可能被线程调度打断。

Java中的原子性操作包括：

1. 基本类型简单赋值操作：对于除long和double之外的基本数据类型（如int, boolean等），简单的读取和赋值操作是原子性的。但是，这并不包括复合操作，例如a++或a += 1。

2. 所有引用reference的赋值操作。

3. java.concurrent.Atomic.* 包中所有类的一切操作

4.内存可见性问题

可见性的定义：可见性指的是在多线程环境下，当多个线程访问同一个变量时，一个线程对这个变量所做的修改能够立即被其他线程所察觉。具体来说，如果一个线程修改了共享变量的值，其他线程应该能够即时看到这一变化。然而，在默认情况下，一个线程对共享变量的操作对于其他线程来说可能是不可见的，因为每个线程可能会缓存变量的副本，或者编译器和处理器为了优化性能而重新排序指令。Java提供了volatile关键字来确保变量修改的可见性。当一个共享变量被声明为volatile后，它就成为了所有读写操作都直接与主内存交互的标志。

5.指令重排序 

有序性的定义：有序性指的是程序执行顺序是否按照代码的书写顺序进行。理想情况下，程序应该严格按照代码的先后顺序执行操作，但在实际中，为了提高性能，编译器和处理器可能会对指令进行重排序。 

 Java内存模型中的有序性可以总结为：如果在本线程内观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有操作都是无序的。前半句是指“线程内表现为串行语义”，后半句是指“指令重排序”现象和“工作内存主主内存同步延迟”现象。
        在Java内存模型中，为了效率是允许编译器和处理器对指令进行重排序，当然重排序不会影响单线程的运行结果，但是对多线程会有影响。Java提供volatile来保证一定的有序性。最著名的例子就是单例模式里面的DCL（双重检查锁）。另外，可以通过synchronized和Lock来保证有序性，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。 

四 解决方案

为了解决多线程环境下同时操作共享数据引发的线程安全问题，我们通常采用同步机制（通过synchronized关键字实现）。同步的核心思想是将涉及共享数据的操作视为一个不可分割的整体，确保当一个线程在执行这段代码时，其他线程无法对其进行访问，直到当前线程完成操作。

同步方案主要可以通过以下三种方式实施，每种方式使用的锁对象各不相同：。

1.同步代码块 

格式：

synchronized（对象）{

        代码块;

} 

public class Demo {private static int count = 0;private static final Object lock = new Object(); // 使用 final 防止锁对象被修改public static void main(String[] args) throws InterruptedException {// 创建两个线程Thread t1 = new Thread(() -> {synchronized (lock) {for (int i = 0; i < 10000; i++) {count++;}}});Thread t2 = new Thread(() -> {synchronized (lock) {for (int i = 0; i < 10000; i++) {count++;}}});// 启动两个线程t1.start();t2.start();// 等待两个线程执行完毕t1.join();t2.join();// 打印最终结果System.out.println("Final Count: " + count);}
}

运行结果: 

2.同步方法 

public class Demo2 {public static int count = 0;public static synchronized void inCrease() {for (int i = 0; i < 10000; i++) {count++;}}public static void main(String[] args) {Thread t1 = new Thread(() -> {inCrease();});Thread t2 = new Thread(() -> {inCrease();});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("Final Count:" + count);}}

运行结果：

3.加锁lock解决问题 

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Demo3 {public static int count = 0;public static Lock lock = new ReentrantLock();public static void inCrease() {lock.lock(); // 获取锁try {for (int i = 0; i < 10000; i++) {count++; // 对共享变量进行操作}} finally {lock.unlock(); // 确保锁一定会被释放}}public static void main(String[] args) {Thread t1 = new Thread(() -> {inCrease();});Thread t2 = new Thread(() -> {inCrease();});t1.start();t2.start();try {t1.join(); // 等待 t1 完成t2.join(); // 等待 t2 完成} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("Final Count: " + count); // 输出最终结果}
}

运行结果： 

本期到这了先，下期见！