1. 线程安全的核心挑战与解决方案概览
想象一下这样的场景：你和几个朋友同时编辑同一个在线文档，如果没有任何协调机制，很可能会出现多人同时修改同一段落导致内容混乱的情况。这就是典型的线程安全问题在现实中的映射。在Java多线程环境中，当多个线程同时访问和修改共享数据时，如果没有适当的同步机制，就会导致数据不一致、逻辑错误等线程安全问题。
线程安全问题的根源主要来自三个方面：
- 原子性破坏：一个操作被线程调度器中断，导致只执行了部分操作
- 可见性问题：一个线程的修改对其他线程不可见
- 指令重排序：编译器和CPU优化导致代码执行顺序与预期不符
Java提供了三大核心机制来解决这些问题：
- synchronized：通过互斥锁保证原子性和可见性
- volatile：保证可见性和禁止指令重排序
- wait/notify：实现线程间的协调通信
我在实际项目中遇到过这样一个案例：一个电商平台的库存管理系统，在促销活动时由于没有处理好线程安全问题，导致超卖了几百件商品。后来通过合理使用synchronized和wait/notify机制，不仅解决了问题，还使系统能承受更高的并发量。
2. synchronized的深度解析与实战
2.1 synchronized的核心特性
synchronized是Java中最基础的同步机制，它就像会议室的门锁——一次只允许一个人进入，其他人必须在门外等待。它的三大核心特性是：
- 互斥性：同一时刻只有一个线程能进入同步代码块
- 可见性：锁释放时所有修改会立即刷新到主内存
- 可重入性：线程可以重复获取已持有的锁
public class Counter { private int count = 0; private final Object lock = new Object(); public void increment() { synchronized(lock) { // 使用专门的对象作为锁 count++; } } }2.2 synchronized的四种使用方式
实例方法同步：锁是当前实例对象(this)
public synchronized void method() { ... }静态方法同步：锁是当前类的Class对象
public static synchronized void staticMethod() { ... }代码块同步（对象锁）
synchronized(this) { ... }代码块同步（类锁）
synchronized(MyClass.class) { ... }
2.3 锁的优化与性能考量
在实际开发中，我总结出几个synchronized的最佳实践：
- 减小同步范围：只同步必要的代码块，避免在同步块中执行耗时操作
- 使用专用锁对象：避免使用字符串常量或基本类型包装类作为锁
- 注意锁粒度：根据场景选择实例锁或类锁
- 避免锁嵌套：容易导致死锁问题
我曾经优化过一个日志服务，原本整个写日志方法都是同步的，导致性能瓶颈。后来改为只同步实际写文件的代码块，吞吐量提升了3倍。
3. volatile的精妙之处与应用场景
3.1 volatile的可见性保证
volatile就像是一个实时公告板——任何线程更新了volatile变量，其他线程都能立即看到最新值。它通过以下机制实现：
- 禁止缓存：直接读写主内存
- 内存屏障：防止指令重排序
public class TaskRunner { private volatile boolean running = true; public void stop() { running = false; } public void run() { while(running) { // 执行任务 } } }3.2 volatile的典型使用场景
状态标志：如上面的示例，用于控制线程启停
单例模式的双重检查锁定
public class Singleton { private static volatile Singleton instance; public static Singleton getInstance() { if(instance == null) { synchronized(Singleton.class) { if(instance == null) { instance = new Singleton(); } } } return instance; } }读多写少的共享变量
需要注意的是，volatile不保证原子性。对于i++这样的复合操作，仍然需要同步。
4. wait/notify机制与线程协作
4.1 生产者-消费者模型实战
wait/notify就像餐厅的厨师(生产者)和服务员(消费者)之间的协作：
public class MessageQueue { private final Queue<String> queue = new LinkedList<>(); private final int maxSize; public MessageQueue(int maxSize) { this.maxSize = maxSize; } public synchronized void produce(String message) throws InterruptedException { while(queue.size() == maxSize) { wait(); // 队列满时等待 } queue.add(message); notifyAll(); // 通知消费者 } public synchronized String consume() throws InterruptedException { while(queue.isEmpty()) { wait(); // 队列空时等待 } String message = queue.poll(); notifyAll(); // 通知生产者 return message; } }4.2 wait/notify使用要点
- 必须在同步块中使用：否则会抛出IllegalMonitorStateException
- 使用while循环检查条件：防止虚假唤醒
- 优先使用notifyAll()：除非能确定只唤醒一个合适的线程
- 注意锁释放：wait()会释放锁，而notify()不会
我在开发一个任务调度系统时，曾因错误使用notify()导致部分工作线程永远无法被唤醒。改用notifyAll()后问题解决，这个教训让我深刻理解了正确使用线程通信机制的重要性。
5. 三剑客的对比与组合使用
5.1 特性对比表
| 特性 | synchronized | volatile | wait/notify |
|---|---|---|---|
| 原子性 | 保证 | 不保证 | 不直接提供 |
| 可见性 | 保证 | 保证 | 依赖synchronized |
| 线程阻塞 | 是 | 否 | 是 |
| 使用复杂度 | 中等 | 低 | 高 |
| 适用场景 | 复合操作 | 状态标志 | 线程协作 |
5.2 组合使用案例
在实际项目中，我们经常需要组合使用这些机制。比如实现一个高性能的缓存：
public class Cache<K, V> { private final Map<K, V> map = new HashMap<>(); private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private volatile boolean initialized = false; public void init() { if(!initialized) { lock.writeLock().lock(); try { if(!initialized) { // 初始化操作 initialized = true; } } finally { lock.writeLock().unlock(); } } } public V get(K key) { lock.readLock().lock(); try { return map.get(key); } finally { lock.readLock().unlock(); } } }这个实现结合了volatile的状态标志和读写锁，既保证了可见性，又提高了读操作的并发性能。
