Java 多线程进阶：线程安全、synchronized、死锁、wait/notify 全解析（含代码示例）
在 Java 并发编程中，“线程安全” 是核心议题之一。本文将深入讲解线程安全的实现手段、
synchronized的使用方式、可重入锁、死锁的成因与避免、wait/notify通信机制等，并配合实际代码案例，帮助你彻底搞懂 Java 线程协作机制。
一、线程安全与加锁机制
1. synchronized 的使用方式
synchronized 是 Java 最基本的加锁工具，保证代码块在多个线程中“互斥”执行。
① 修饰普通方法（锁的是当前实例 this）
public synchronized void syncMethod() {// 线程安全的逻辑
}
② 修饰静态方法（锁的是当前类的 .class 对象）
public synchronized static void staticSyncMethod() {// 静态同步逻辑
}
③ 修饰代码块（可以灵活选择锁对象）
public void method() {synchronized (this) {// 同步逻辑}
}
2. 锁竞争与锁冲突
-
同一对象加锁：多个线程竞争同一把锁，会造成阻塞等待（锁冲突）。
-
不同对象加锁：互不干扰，线程可并发执行。
Runnable task = () -> {synchronized (lockObject) {// 临界区代码}
};
二、可重入性：不会死锁的“重复加锁”
Java 的 synchronized 是可重入锁。也就是说，一个线程可以多次获得同一把锁，不会导致死锁。
public synchronized void outer() {inner(); // 同一线程再次进入 synchronized 方法
}public synchronized void inner() {// 安全执行
}
三、死锁问题与避免
死锁产生的典型场景
1. 两个线程两把锁，互相等待对方释放
class DeadlockExample {private final Object lock1 = new Object();private final Object lock2 = new Object();public void task1() {synchronized (lock1) {System.out.println("Task1 获得了lock1");try { Thread.sleep(100); } catch (InterruptedException ignored) {}synchronized (lock2) {System.out.println("Task1 获得了lock2");}}}public void task2() {synchronized (lock2) {System.out.println("Task2 获得了lock2");try { Thread.sleep(100); } catch (InterruptedException ignored) {}synchronized (lock1) {System.out.println("Task2 获得了lock1");}}}
}
这个例子满足死锁的 4 个必要条件，其中最核心的是“循环等待”。
死锁避免策略
-
统一加锁顺序：总是先加 lock1，再加 lock2，避免循环依赖。
-
使用
tryLock()+ 超时机制（需使用ReentrantLock）。
四、线程通信：wait 和 notify 的正确使用方式
使用wait() 和 notify() 方法。
-
wait()：线程 自愿等待，进入“暂停”状态，直到被别人叫醒。 -
notify()：叫醒一个正在等待的线程。 -
notifyAll()：叫醒所有等待的线程（但只有一个能拿到锁继续执行）。
使用场景举例：先执行线程 t1 的一部分，再由线程 t2 接力。
class Task {private final Object lock = new Object();private boolean ready = false;public void part1() {synchronized (lock) {System.out.println("T1 正在执行前半部分任务");try { Thread.sleep(1000); } catch (InterruptedException ignored) {}ready = true;lock.notify(); // 唤醒 T2}}public void part2() {synchronized (lock) {while (!ready) {try {lock.wait(); // 主动释放锁并阻塞} catch (InterruptedException ignored) {}}System.out.println("T2 收到通知，继续执行后续任务");}}
}public class WaitNotifyDemo {public static void main(String[] args) {Task task = new Task();Thread t1 = new Thread(task::part1);Thread t2 = new Thread(task::part2);t2.start(); // T2 先 waitt1.start(); // T1 后 notify}
}
与
join()和sleep()相比，wait/notify更灵活，支持提前唤醒和条件控制。
wait 的底层流程
-
释放锁
-
阻塞等待
-
被唤醒后重新竞争锁
-
重新获取锁并继续执行
notify 与 notifyAll 的区别
-
notify()：随机唤醒一个正在wait()的线程。 -
notifyAll()：唤醒所有等待线程，但只有一个能成功获得锁。
五、volatile 与内存可见性
在多线程环境中，每个线程可能并不直接操作主内存中的变量，而是从主内存读取变量到自己的缓存中进行操作。这就可能出现这样的情况：
-
一个线程修改了变量的值，但另一个线程看不到这个变化（因为仍在用旧的缓存）。
-
导致线程间的通信出现“看不见的修改”。
这就是内存可见性问题。
示例代码
public class VisibilityProblem {private static boolean running = true;public static void main(String[] args) {Thread t = new Thread(() -> {while (running) {// 执行代码}System.out.println("线程停止");});t.start();try { Thread.sleep(1000); } catch (InterruptedException ignored) {}running = false; // 主线程修改 runningSystem.out.println("主线程修改 running 为 false");}
}
可能结果：
即使主线程已经把 running 改为 false，t 线程可能还一直在死循环，因为它使用的是本地缓存值而不是主内存的值。
解决方式：使用 volatile
private static volatile boolean running = true;
一旦使用 volatile 修饰变量，修改后的值会立刻刷新到主内存，并且所有线程每次访问变量时都会从主内存读取，从而保证了内存可见性。
结语
Java 多线程的本质是对“共享资源 + 并发访问”下的一种控制与协作。理解 synchronized 的使用方式、死锁的本质、以及 wait/notify 的协作机制，能有效帮助我们写出更安全、灵活的并发程序。