Java 线程安全核心：synchronized、volatile 与 wait/notify | 极客日志

Javajava

Java 线程安全核心：synchronized、volatile 与 wait/notify

探讨 Java 多线程环境下的线程安全问题，分析导致不安全的三大原因：原子性、内存可见性与指令重排序。重点讲解 synchronized 关键字如何实现原子性、可见性及互斥锁，volatile 如何保证可见性与禁止重排序，以及 wait/notify 机制在线程通信中的应用。同时涵盖死锁产生的条件与预防策略，并通过代码示例演示各机制的实际效果。

CoderByte发布于 2026/3/24更新于 2026/5/1121 浏览

Java 线程安全核心：synchronized、volatile 与 wait/notify

1.线程安全

1.1 概念&示例

概念：指在多线程环境下，某个代码、函数或对象能够被多个线程同时调用或访问时，仍能保持正确的行为和数据一致性。简单来说，线程安全的代码在多线程环境下运行可靠，不会因线程间的交互而产生不可预测的结果

示例：

public class ThreadDemo {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 500000; i++) {
                count++;
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 500000; i++) {
                count++;
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("count = " + count); // 每次执行的结果都不一致
    }
}

按照上述代码的逻辑，期望得到的结果是 1000000，但实际计算的结果与期望值不一致。线程不安全：当多个线程同时访问或修改时，由于缺乏适当的，可能导致程序行为不可预测、数据损坏或错误结果的现象

public class ThreadDemo {
    // 锁对象
    private static final Object locker = new Object();
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 500000; i++) {
                synchronized (locker) {
                    count++;
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 500000; i++) {
                synchronized (locker) {
                    count++;
                }
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("count = " + count); // 1000000
    }
}

public class Reentry_Lock {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread thread = new Thread(() -> {
            synchronized (locker) {
                System.out.println("第一层锁");
                synchronized (locker) {
                    System.out.println("第二层锁");
                }
            }
        });
        thread.start();
    }
}

public class Example {
    // 实例方法锁
    public synchronized void instanceMethod() {
        // 同步代码
    }
    // 实例代码块锁
    public void anotherMethod() {
        synchronized (this) {
            // 同步代码
        }
    }
}

public class Example {
    // 静态方法锁
    public static synchronized void staticMethod() {
        // 同步代码
    }
    // 静态代码块锁
    public static void anotherStaticMethod() {
        synchronized (Example.class) {
            // 同步代码
        }
    }
}

public class demo_volatile {
    // 每次访问都会强制从主内存读取，每次修改都会立即写回主内存
    // 去除 volatile 关键字会导致 thread1 线程在访问 num 时不从主内存读取
    public static volatile int num = 0;
    public static void main(String[] args) {
        // thread1 线程的生命周期掌握在 thread2 手中
        Thread thread1 = new Thread(() -> {
            while (num == 0) {}
            System.out.println("Over thread1");
        });
        Thread thread2 = new Thread(() -> {
            System.out.println("请输入一个整数");
            Scanner in = new Scanner(System.in);
            num = in.nextInt();
        });
        thread1.start();
        thread2.start();
    }
}

public class FixedReorderingExample {
    int a = 0; // 普通变量
    int b = 0; // 普通变量
    volatile boolean flag = false; // 标志变量使用 volatile

    // 写线程方法
    public void writer() {
        a = 1;
        b = 1;
        flag = true; // volatile 写，插入写屏障：确保 flag 写操作在 a、b 写操作之后
    }

    // 读线程方法
    public void reader() {
        if (flag) { // volatile 读，插入读屏障：确保 println 读操作不会再 if 读操作之前
            int r1 = a;
            int r2 = b;
            System.out.println("r1: " + r1 + ", r2: " + r2); // 总是输出 r1: 1, r2: 1
        }
    }
}

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread thread1 = new Thread(() -> {
            // thread1 拿到锁
            synchronized (locker) {
                System.out.println("thread1 线程 wait 之前");
                try {
                    // thread1 释放锁，进入 waiting 状态，等待被唤醒
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("thread1 线程 wait 之后");
            }
        });
        Thread thread2 = new Thread(() -> {
            // thread1 进入 waiting 之后，thread2 拿到锁
            synchronized (locker) {
                System.out.println("thread2 线程 notify 之前");
                // 虽然 notify 执行之后 thread1 被唤醒了，但此时仍处于 thread2 的 synchronized 中
                // 同一对象才能唤醒
                locker.notify();
                System.out.println("thread2 线程 notify 之后");
            }
        });
        thread1.start();
        Thread.sleep(1000);
        thread2.start();
    }
}