线程安全指多线程并发访问共享资源时程序行为正确，核心在于原子性、可见性、有序性。原子性保障操作不可分割，通过synchronized、Lock或Atomic类实现；可见性确保线程间修改及时可见，由volatile、synchronized或final保证；有序性防止指令重排序，依赖volatile和synchronized维持执行顺序。三者共同构建并发安全的基石。
线程安全，简单来说，就是指在多线程环境下，当多个线程并发访问同一段代码或同一份共享数据时，程序的行为仍然是可预测的、正确的，不会因为并发导致数据损坏或逻辑错误。而Java中理解线程安全，核心就在于掌握并发编程的三大特性：原子性、可见性和有序性，它们分别保障了操作的不可分割、内存修改的及时同步以及指令执行的顺序一致性。
当我们谈论线程安全，其实是在聊一个很实际的问题：当程序里的多个“工人”（线程）同时去操作同一个“工具箱”（共享变量）时，怎么才能保证这个工具箱不会被搞乱，每个工人都能拿到正确的东西，并且最终的结果是大家预期的？这在单线程世界里根本不是个事儿，但一旦引入并发，各种意想不到的问题就冒出来了，比如数据脏读、丢失更新，甚至死锁。
我个人觉得，线程安全不仅仅是写出没有bug的代码，更是一种思维模式的转变。它要求我们从一开始就预设：任何共享资源都可能被多个线程同时访问。这种预设会引导我们去思考如何保护这些资源，无论是通过加锁、使用并发容器，还是通过无锁算法。它强迫我们去理解底层内存模型，去思考数据在不同CPU缓存之间是如何同步的。很多时候，我们以为加个
synchronized
线程不安全之所以会导致程序行为异常，根源在于CPU的执行方式和内存模型的复杂性。举个最简单的例子，一个
i++
i
i
i
i++
i
i
i
i
i
立即学习“Java免费学习笔记（深入）”；
更深层次看，现代CPU为了性能，会有多级缓存。每个CPU核心都有自己的L1、L2缓存，L3缓存可能由多个核心共享。当一个线程修改了某个变量，这个修改可能只先写到了它所在CPU核心的缓存里，并没有立即刷新到主内存。如果另一个线程在另一个CPU核心上读取这个变量，它读到的可能是旧值。这就是“可见性”问题。
还有指令重排序。编译器和处理器为了优化性能，可能会对指令进行重新排序，只要最终结果在单线程环境下保持一致。但在多线程环境下，这种重排序可能会打乱我们预设的执行顺序，导致一些依赖于特定顺序的并发操作出现问题。比如，一个对象的初始化和对其引用赋值，如果重排序了，其他线程可能在对象还没完全初始化完成时就拿到了它的引用，导致空指针或其他异常。这些都是我们肉眼难以察觉，却实实在在会影响程序正确性的因素。
原子性，顾名思义，就是指一个或多个操作，要么全部执行成功，要么全部不执行，中间不能被任何因素打断。它是一个不可分割的整体。在Java里，最直观的原子操作就是基本数据类型的读写（除了
long
double
i++
要保障复合操作的原子性，最常见也最直接的手段就是使用锁机制。比如
synchronized
synchronized
public class AtomicExample {
private int count = 0;
public synchronized void increment() {
count++; // 这里的count++操作在synchronized块内，因此是原子的
}
public int getCount() {
return count;
}
}除了
synchronized
java.util.concurrent.locks.Lock
ReentrantLock
lock()
unlock()
此外，java.util.concurrent.atomic
AtomicInteger
AtomicLong
AtomicReference
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerExample {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // AtomicInteger的incrementAndGet方法是原子的
}
public int getCount() {
return count.get();
}
}我个人觉得，选择哪种方式，很多时候取决于具体场景和性能要求。
synchronized
Lock
可见性和有序性，这两兄弟在并发编程中常常是隐形的杀手，它们不像原子性那样直接导致数据计算错误，而是通过更微妙的方式让程序行为变得不可预测。
可见性（Visibility）： 简单来说，可见性是指当一个线程修改了共享变量的值，其他线程能够立即（或者说，及时）看到这个修改。正如前面提到的CPU缓存问题，一个线程对共享变量的修改，可能仅仅停留在自己的工作内存（CPU缓存）中，而没有及时刷新到主内存。其他线程如果从主内存或者自己的旧缓存中读取，就会读到过期的值。
Java中保障可见性的主要手段有：
volatile
volatile
volatile
volatile
volatile int i = 0; i++;
i++
synchronized
synchronized
synchronized
synchronized
final
final
this
final
java.util.concurrent
Atomic
CountDownLatch
CyclicBarrier
ThreadPoolExecutor
有序性（Ordering）： 有序性是指程序执行的顺序，在单线程环境下，我们通常认为代码是按照书写顺序执行的。但在多线程环境下，编译器和处理器为了优化性能，可能会对指令进行重排序，只要不改变单线程程序的执行结果（as-if-serial语义）。这种重排序在并发场景下就可能出问题。
例如经典的双重检查锁定（DCL）单例模式，如果不对实例变量使用
volatile
// 假设这是DCL单例模式的错误示范（缺少volatile）
public class Singleton {
private static Singleton instance; // 缺少volatile
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton(); // 1. 分配内存 2. 初始化对象 3. 设置instance指向内存
}
}
}
return instance;
}
}在
instance = new Singleton();
instance
如果2和3发生了重排序，变成了1 -> 3 -> 2，那么在步骤3完成后，
instance
null
instance
null
volatile
instance
保障有序性的主要手段：
volatile
volatile
synchronized
synchronized
总的来说，理解这三特性，就像是理解并发世界的“物理定律”。原子性是操作的完整性，可见性是状态的同步性，有序性是指令的逻辑序列。它们共同构成了我们构建健壮并发程序的基石，缺一不可。很多时候，我们遇到的并发问题，追根溯源，往往是这三者中的一个或多个没有被妥善处理。这需要我们深入思考，而不是简单地堆砌同步机制。
以上就是什么是线程安全？如何理解Java中的“原子性”、“可见性”、“有序性”？的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
722
收藏
