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 先 wait
        t1.start(); // T1 后 notify
    }
}

与 join() 和 sleep() 相比，wait/notify 更灵活，支持提前唤醒和条件控制。

---

wait 的底层流程

1. 释放锁

2. 阻塞等待

3. 被唤醒后重新竞争锁

4. 重新获取锁并继续执行

---

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; // 主线程修改 running
        System.out.println("主线程修改 running 为 false");
    }
}

可能结果：

即使主线程已经把 running 改为 false，t 线程可能还一直在死循环，因为它使用的是本地缓存值而不是主内存的值。

解决方式：使用 volatile

private static volatile boolean running = true;

 一旦使用 volatile 修饰变量，修改后的值会立刻刷新到主内存，并且所有线程每次访问变量时都会从主内存读取，从而保证了内存可见性。

---

结语

Java 多线程的本质是对“共享资源 + 并发访问”下的一种控制与协作。理解 synchronized 的使用方式、死锁的本质、以及 wait/notify 的协作机制，能有效帮助我们写出更安全、灵活的并发程序。