Java 并发编程 3 大核心问题实战：原子性、可见性、有序性代码复现与解决
·
Java 并发编程 3 大核心问题实战：原子性、可见性、有序性代码复现与解决
1. 并发编程的核心挑战
现代软件开发中，多核处理器已成为标配，而并发编程是充分利用硬件性能的关键手段。然而，并发编程并非简单地创建多个线程就能获得性能提升，它带来了三个核心挑战：原子性（Atomicity）、可见性（Visibility）和有序性（Ordering）。理解这三大问题对于编写正确、高效的并发程序至关重要。
原子性问题 源于线程切换导致的指令交错执行。例如，当多个线程同时修改一个共享变量时，看似简单的 count++ 操作实际上包含读取-修改-写入三个步骤，若这些步骤被其他线程打断，就会导致数据不一致。
可见性问题 则由现代计算机架构的多级缓存机制引起。每个CPU核心都有自己的缓存，线程对共享变量的修改可能暂时只存在于本地缓存，未及时同步到主内存，导致其他线程看到的仍是旧值。
有序性问题 更为隐蔽，它来自于编译器和处理器的指令重排序优化。虽然重排序能提升性能，但在多线程环境下可能破坏程序的逻辑顺序，导致意外结果。
// 典型的问题复现场景
public class ConcurrencyProblemDemo {
private int count = 0;
public void increment() {
count++; // 非原子操作
}
public int getCount() {
return count; // 可能读到过期值
}
}
2. 原子性问题实战
2.1 原子性问题复现
让我们通过一个银行转账的例子来演示原子性问题。假设有两个线程同时向同一个账户存款，如果没有适当的同步措施，最终余额可能会出现错误。
public class AtomicityProblem {
private int balance = 100;
public void deposit(int amount) {
int newBalance = balance + amount;
// 模拟处理延迟
try { Thread.sleep(10); } catch (InterruptedException e) {}
balance = newBalance;
}
public static void main(String[] args) throws InterruptedException {
AtomicityProblem account = new AtomicityProblem();
Thread t1 = new Thread(() -> account.deposit(50));
Thread t2 = new Thread(() -> account.deposit(50));
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final balance: " + account.balance);
// 预期200，实际可能是150
}
}
2.2 原子性解决方案
Java提供了多种保证原子性的机制：
-
synchronized关键字 ：最基础的同步手段
public synchronized void deposit(int amount) { balance += amount; } -
Lock接口 ：更灵活的锁控制
private final Lock lock = new ReentrantLock(); public void deposit(int amount) { lock.lock(); try { balance += amount; } finally { lock.unlock(); } } -
原子类 ：基于CAS的无锁实现
private AtomicInteger balance = new AtomicInteger(100); public void deposit(int amount) { balance.addAndGet(amount); }
对比表格 ：
| 方案 | 性能 | 适用场景 | 特点 |
|---|---|---|---|
| synchronized | 中等 | 简单同步需求 | JVM内置支持，自动释放锁 |
| Lock | 高 | 复杂同步需求 | 可中断、超时、公平锁等高级特性 |
| 原子类 | 最高 | 计数器等简单操作 | 无锁实现，CAS机制 |
3. 可见性问题实战
3.1 可见性问题复现
可见性问题通常表现为一个线程的修改对另一个线程不可见。以下代码展示了典型的可见性问题：
public class VisibilityProblem {
private boolean running = true;
public void start() {
new Thread(() -> {
while (running) {
// 空循环
}
System.out.println("Thread stopped");
}).start();
}
public void stop() {
running = false;
}
public static void main(String[] args) throws InterruptedException {
VisibilityProblem demo = new VisibilityProblem();
demo.start();
Thread.sleep(1000);
demo.stop();
// 子线程可能永远不会停止
}
}
3.2 可见性解决方案
-
volatile关键字 ：确保变量的读写直接作用于主内存
private volatile boolean running = true; -
synchronized同步 ：同步块不仅保证原子性，也保证可见性
private boolean running = true; public synchronized boolean isRunning() { return running; } public synchronized void setRunning(boolean running) { this.running = running; } -
final字段 ：正确构造的对象，final字段对其他线程可见
private final Map<String, String> config; public VisibilitySolution(Map<String, String> config) { this.config = new HashMap<>(config); }
关键点对比 ：
volatile适用于单个变量的读写场景，开销小于synchronizedsynchronized适用于复合操作，同时解决原子性和可见性问题final适用于初始化后不再修改的共享变量
4. 有序性问题实战
4.1 有序性问题复现
指令重排序可能导致看似顺序执行的代码在实际运行时顺序发生变化。以下是一个可能出问题的双重检查锁定单例模式：
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); // 可能发生重排序
}
}
}
return instance;
}
}
4.2 有序性解决方案
-
volatile关键字 ：禁止指令重排序
private static volatile Singleton instance; -
happens-before原则 ：Java内存模型定义的一系列保证有序性的规则
-
final字段 ：final字段的初始化保证对其他线程可见
// 正确的双重检查锁定实现
public class SafeSingleton {
private static volatile SafeSingleton instance;
private SafeSingleton() {}
public static SafeSingleton getInstance() {
if (instance == null) {
synchronized (SafeSingleton.class) {
if (instance == null) {
instance = new SafeSingleton();
}
}
}
return instance;
}
}
happens-before规则示例 ：
- 程序顺序规则 ：同一线程中的操作按程序顺序执行
- 锁规则 ：解锁操作先于后续的加锁操作
- volatile规则 ：volatile写操作先于后续的读操作
- 线程启动规则 ：线程的start()调用先于该线程的任何操作
- 线程终止规则 ：线程的所有操作先于其他线程检测到该线程已终止
5. 综合解决方案与最佳实践
5.1 并发工具类选择指南
根据不同的并发需求，Java提供了多种并发工具：
| 工具类 | 适用场景 | 特点 |
|---|---|---|
| synchronized | 简单同步需求 | 内置支持，自动释放锁 |
| ReentrantLock | 需要高级特性 | 可中断、超时、公平锁 |
| AtomicXXX | 计数器等简单操作 | 无锁，高性能 |
| volatile | 状态标志 | 轻量级可见性保证 |
| ConcurrentHashMap | 并发Map | 分段锁，高并发访问 |
5.2 性能优化技巧
-
减小锁粒度 ：只锁定必要的代码段
// 不推荐 - 锁范围过大 public synchronized void process() { // 大量不相关的操作 } // 推荐 - 精确锁定 public void process() { // 无关操作 synchronized(this) { // 需要同步的操作 } // 更多无关操作 } -
避免锁嵌套 ：防止死锁
// 危险的锁嵌套 public void transfer(Account from, Account to, int amount) { synchronized(from) { synchronized(to) { // 转账逻辑 } } } -
使用读写锁 ：读多写少场景
private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); public void readData() { rwLock.readLock().lock(); try { // 读操作 } finally { rwLock.readLock().unlock(); } } public void writeData() { rwLock.writeLock().lock(); try { // 写操作 } finally { rwLock.writeLock().unlock(); } }
5.3 常见陷阱与规避方法
-
死锁 ：按固定顺序获取锁
// 安全的锁获取顺序 public void safeTransfer(Account a, Account b, int amount) { Account first = a.id < b.id ? a : b; Account second = a.id < b.id ? b : a; synchronized(first) { synchronized(second) { // 转账逻辑 } } } -
活锁 ：引入随机退避机制
while (!tryAcquireLock()) { Thread.sleep(random.nextInt(100)); // 随机退避 } -
线程饥饿 ：使用公平锁
Lock fairLock = new ReentrantLock(true); // 公平锁
6. 实战案例分析
6.1 高性能计数器实现
public class HighPerformanceCounter {
private final AtomicLong counter = new AtomicLong(0);
private final LongAdder fastCounter = new LongAdder();
// 简单原子操作
public void incrementAtomic() {
counter.incrementAndGet();
}
// 高并发优化
public void incrementLongAdder() {
fastCounter.increment();
}
// 获取当前值
public long getAtomicValue() {
return counter.get();
}
public long getLongAdderValue() {
return fastCounter.sum();
}
}
6.2 线程安全缓存实现
public class ThreadSafeCache<K, V> {
private final Map<K, V> cache = new ConcurrentHashMap<>();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public V get(K key) {
lock.readLock().lock();
try {
return cache.get(key);
} finally {
lock.readLock().unlock();
}
}
public void put(K key, V value) {
lock.writeLock().lock();
try {
cache.put(key, value);
} finally {
lock.writeLock().unlock();
}
}
public V computeIfAbsent(K key, Function<K, V> mappingFunction) {
// 使用ConcurrentHashMap的原子方法
return cache.computeIfAbsent(key, mappingFunction);
}
}
6.3 生产者-消费者模式实现
public class ProducerConsumer {
private final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
public void start() {
// 生产者
new Thread(() -> {
try {
for (int i = 0; i < 100; i++) {
queue.put(i);
System.out.println("Produced: " + i);
Thread.sleep(100);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
// 消费者
new Thread(() -> {
try {
while (true) {
Integer item = queue.take();
System.out.println("Consumed: " + item);
Thread.sleep(200);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
}
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
9
0- 0
已为社区贡献12条内容
所有评论(0)