Java 什么是线程安全及如何实现线程安全
1. 什么是线程安全？
线程安全 指的是在多线程环境下，某个类、方法或对象能够正确、一致地处理共享数据，无需额外的同步机制即可保证：
-
原子性（Atomicity）：操作不可分割，要么全部完成，要么全部不执行。
-
可见性（Visibility）：一个线程修改共享变量后，其他线程能立即看到最新值。
-
有序性（Ordering）：代码执行顺序符合预期，避免指令重排序导致的逻辑错误。
线程不安全的典型表现：
-
数据竞争（Data Race）：多线程同时修改共享变量导致结果不可预测。
-
脏读（Dirty Read）：读取到其他线程未完成的中间状态数据。
-
死锁（Deadlock）：多个线程互相等待对方释放锁，导致永久阻塞。
2. Java 中如何实现线程安全？
以下是 Java 中实现线程安全的 7 种核心方法，每种方法均附有代码示例和适用场景。
2.1 使用 synchronized 关键字
原理：通过 JVM 内置锁（Monitor）实现互斥访问，确保同一时间只有一个线程执行临界区代码。
示例：
java
复制
public class Counter {
private int count = 0;
// 同步方法
public synchronized void increment() {
count++;
}
// 同步代码块
public void incrementWithBlock() {
synchronized (this) {
count++;
}
}
}
适用场景：
-
简单的同步需求（如单例模式、计数器）。
-
对性能要求不高，优先保证代码简洁性。
2.2 使用 ReentrantLock 显式锁
原理：基于 java.util.concurrent.locks.ReentrantLock，提供比 synchronized 更灵活的锁控制（如可中断、超时、公平锁）。
示例：
java
复制
public class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
适用场景：
-
需要高级锁功能（如
tryLock()、lockInterruptibly()）。 -
高并发场景下的细粒度锁控制。
2.3 使用原子类（Atomic Classes）
原理：基于 CAS（Compare-and-Swap）实现无锁线程安全操作，适用于简单原子操作。
示例：
java
复制
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // 原子递增
}
}
适用场景：
-
单一变量的原子操作（如计数器、标志位）。
-
低竞争场景，避免锁开销。
2.4 使用 volatile 关键字
原理：保证变量的可见性和禁止指令重排序，但不保证原子性。
示例：
java
复制
public class VolatileExample {
private volatile boolean flag = false;
public void toggleFlag() {
flag = !flag; // 非原子操作，需配合 synchronized 或原子类使用
}
}
适用场景：
-
状态标志（如开关控制），一写多读场景。
-
配合其他机制（如
synchronized）保证复合操作的原子性。
2.5 使用不可变对象（Immutable Objects）
原理：对象创建后状态不可变，天然线程安全。
示例：
java
复制
public final class ImmutablePerson {
private final String name;
private final int age;
public ImmutablePerson(String name, int age) {
this.name = name;
this.age = age;
}
// 无 setter 方法
public String getName() { return name; }
public int getAge() { return age; }
}
适用场景：
-
配置信息、常量等只读数据。
-
避免深拷贝或防御性拷贝的开销。
2.6 使用线程封闭（Thread Confinement）
原理：通过 ThreadLocal 为每个线程创建独立的变量副本，避免共享。
示例：
java
复制
public class UserContext {
private static ThreadLocal<User> userHolder = new ThreadLocal<>();
public static void setUser(User user) {
userHolder.set(user);
}
public static User getUser() {
return userHolder.get();
}
}
适用场景：
-
用户会话、数据库连接等线程隔离数据。
-
避免传递参数的繁琐性。
2.7 使用并发容器（Concurrent Collections）
原理：Java 提供线程安全的集合类，内部已实现同步机制。
示例：
java
复制
public class Cache {
private ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
public void put(String key, Object value) {
map.put(key, value);
}
public Object get(String key) {
return map.get(key);
}
}
适用场景：
-
高并发环境下的数据存储（如缓存、任务队列）。
-
替代
Collections.synchronizedXXX()提升性能。
3. 线程安全实现对比表
| 方法 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
synchronized | 简单、自动释放锁 | 功能单一、性能中等 | 简单同步需求 |
ReentrantLock | 灵活（超时、中断、公平锁） | 需手动释放锁，代码复杂 | 高并发、需要高级锁功能 |
| 原子类 | 无锁、高性能 | 仅支持单一变量原子操作 | 计数器、标志位 |
volatile | 轻量级可见性保证 | 不保证原子性 | 状态标志、配合其他机制使用 |
| 不可变对象 | 天然线程安全 | 需要创建新对象 | 配置信息、常量 |
ThreadLocal | 线程隔离、无竞争 | 内存泄漏风险 | 用户会话、线程上下文 |
| 并发容器 | 高性能、内置同步 | 功能受限 | 高并发集合操作 |
4. 常见面试问题示例
Q1：synchronized 和 ReentrantLock 的区别？
-
synchronized是 JVM 内置锁，自动释放；ReentrantLock是 API 级锁，需手动释放。 -
ReentrantLock支持可中断、超时、公平锁，synchronized不支持。
Q2：volatile 能替代 synchronized 吗？
-
不能。
volatile仅保证可见性和有序性，不保证原子性。例如volatile int i = 0; i++是非原子操作。
Q3：如何设计一个线程安全的单例模式？
-
双重检查锁（DCL） +
volatile：java
复制
public class Singleton { private static volatile Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }
总结
实现线程安全的核心在于 控制共享数据的访问，具体方法需根据场景选择：
-
简单同步 →
synchronized -
高性能无锁 → 原子类
-
复杂控制 →
ReentrantLock -
状态标志 →
volatile -
数据隔离 →
ThreadLocal -
高并发集合 → 并发容器
理解线程安全的三要素（原子性、可见性、有序性）是解决多线程问题的关键。
测试用例：
package com.example.MySpringBootTest.test.threadsafe;
import java.util.ArrayList;
import java.util.List;
public class ThreadSafeExample {
public static void main(String[] args) throws InterruptedException {
List<Integer> list = new ArrayList<>();
Object lock = new Object();
Thread thread = new Thread(() -> {
synchronized (lock) {
for (int i = 0; i < 1000; i++) {
list.add(i);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
Thread thread1 = new Thread(() -> {
synchronized (lock) {
for (int i = 0; i < 500; i++) {
if (!list.isEmpty()) {
list.remove(0);
}
try {
Thread.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
thread.start();
thread1.start();
thread.join();
thread1.join();
System.out.println("列表最终大小: " + list.size());
}
}
当没有用 synchronized 做锁排序时候，列表最终大小: 经常不等于500，浮现了非线程安全。加锁后，对并发线程做了串行化，列表最终大小: 500。