线程安全问题的原因与解决方案总结_线程安全问题出现的原因和解决方法-优快云博客

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中的原子性操作包括：

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

所有引用reference的赋值操作。

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); // 输出最终结果
    }
}

运行结果：