使用synchronized、volatile、Atomic类和ReentrantLock可解决Java多线程共享变量问题。synchronized保证原子性和可见性，适用于同步方法或代码块；volatile确保变量可见性和禁止重排序，适合状态标志；Atomic类基于CAS实现高效原子操作，常用于计数器；ReentrantLock提供更灵活的锁控制，如可中断和超时。根据场景选择：简单同步用synchronized，高性能原子操作选Atomic，复杂锁逻辑用ReentrantLock，轻量级通知用volatile。
在Java中，多个线程共享同一个变量时，可能会出现数据不一致、脏读、丢失更新等问题。要正确处理多线程共享变量，关键在于保证可见性、原子性和有序性。以下是几种常用且有效的解决方案。
使用 synchronized 关键字
synchronized 可以保证同一时刻只有一个线程执行某段代码，同时确保线程之间的可见性和操作的原子性。
你可以用它来修饰方法或代码块：
- 修饰实例方法：锁住当前实例对象（this）- 修饰静态方法：锁住类的 Class 对象
- 修饰代码块：指定一个锁对象
示例：
public class Counter {
private int count = 0;
public synchronized void increment() {
count++; // 原子操作
}
public synchronized int getCount() {
return count;
}}
这样能防止多个线程同时修改 count 变量。
使用 volatile 关键字
volatile 适用于变量本身不需要复合操作（如 i++），但需要保证修改对其他线程立即可见的情况。
volatile 能保证可见性和禁止指令重排序，但不能保证原子性。
适合场景：状态标志位
public class Worker {
private volatile boolean running = true;
public void stop() {
running = false;
}
public void run() {
while (running) {
// 执行任务
}
}}
一个线程调用 stop()，另一个线程能立即看到 running 变为 false。
使用 java.util.concurrent.atomic 包
AtomicInteger、AtomicLong 等类提供原子操作，适合计数器、状态变量等场景。
它们基于 CAS（Compare-And-Swap）机制实现，性能通常优于 synchronized。
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // 原子自增
}
public int getCount() {
return count.get();
}}
这种方式既高效又线程安全。
使用显式锁（ReentrantLock）
ReentrantLock 提供了比 synchronized 更灵活的锁控制，比如可中断、超时获取锁等。
import java.util.concurrent.locks.ReentrantLock;
public class LockCounter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}}
注意一定要在 finally 中释放锁，避免死锁。
基本上就这些常见方式。选择哪种取决于你的具体需求：如果只是简单同步方法，synchronized 最方便；需要高性能原子操作用 Atomic 类；复杂锁逻辑考虑 ReentrantLock；而 volatile 适合轻量级的状态通知。关键是理解每种机制的适用边界，避免误用。
}
public void run() {
while (running) {
// 执行任务
}
}
