Java内功修炼(2)——线程安全三剑客：synchronized、volatile与wait/notify

用户11873138

发布于 2026-01-13 21:38:38

1250

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，但实际计算的结果与期望值不一致 线程不安全：当多个线程同时访问或修改共享资源时，由于缺乏适当的同步机制，可能导致程序行为不可预测、数据损坏或错误结果的现象

1.2 线程不安全的原因

1.访问修改共享变量：当多个线程同时读写同一内存区域时，可能导致数据状态不一致
2.原子性：原子性指一个操作是不可分割的单元，要么完全执行，要么完全不执行。如果操作不是原子的，在并发环境下，线程可能被中断在中间状态，导致部分修改

3.内存可见性：在多线程编程中，每个线程都有自己的工作内存(本地内存)，用于存储共享变量的副本。由于CPU缓存、编译器优化等因素，操作可能只发生在工作内存中，而不是直接在主内存中进行，导致程序行为不符合预期

4.指令重排序：是计算机处理器或编译器为了提高程序执行效率，对指令执行顺序进行优化的一种技术。在保证程序最终结果正确的前提下，允许指令的执行顺序与代码编写的顺序不一致。但可能导致多线程下的逻辑错误

5.线程之间抢占式执行：这是操作系统层面的调度机制，线程的执行顺序是随机的和不可预测的。操作系统可能随时中断一个线程(抢占)，切换到另一个线程执行。一般不轻易改变，当引发线程安全时优先考虑前4个原因

共享变量访问修改是线程安全问题的前提，但需结合2/3/4才会引发问题；抢占式执行是线程调度的特性，无法避免

2.synchronized关键字

2.1 概念

synchronized(监视器锁monitor lock)：用于实现线程同步，确保多线程环境下对共享资源的访问安全。通过加锁机制，防止多个线程同时访问同步块代码或对象，避免数据不一致问题

2.2 特性

2.2.1 原子性

确保了代码块的原子性，即被同步的代码块在执行过程中不会被其他线程中断。这意味着在一个线程执行完整个同步块之前，其他线程无法进入同一个同步块，从而保证了操作的完整性

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
    }
}

2.2.2 内存可见性

获取锁时：线程会将工作内存中的变量副本失效，强制从主内存重新读取最新值
释放锁时：线程会将工作内存中修改过的变量刷新到主内存

这种机制确保了共享变量的修改对所有线程立即可见

2.2.3 互斥性

确保在同一时间只有一个线程可以进入被同步的代码块或方法，这意味着当一个线程进入同步块或方法时，其他试图进入同一同步块的线程会被阻塞，直到第一个线程退出同步块

2.2.4 可重入性

synchronized关键字是可重入的，这意味着如果一个线程已经持有某个对象的锁，那么它可以再次获取该对象的锁，而不会被阻塞

可重入锁通常会维护一个计数器，记录当前线程获取锁的次数。每次获取锁时，计数器加一；释放锁时，计数器减一。当计数器为零时，锁才真正被释放

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();
    }
}

2.3 类型

2.3.1 实例锁

作用于对象实例，每个对象实例拥有自己的锁。当一个线程访问对象的synchronized实例方法或代码块时，其他线程无法访问该对象的其他synchronized方法或代码块，但可以访问非synchronized方法或代码块

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

2.3.2 静态锁

作用于类的Class对象，所有实例共享同一把锁。当一个线程访问synchronized静态方法或代码块时，其他线程无法访问该类的其他synchronized静态方法或代码块，但可以访问非synchronized静态方法或代码块

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

2.4 死锁

概念：指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，导致这些线程都无法继续执行下去。这种情况下，系统资源被占用，但程序无法继续运行

死锁产生的必要条件：

1.互斥条件(Mutual Exclusion)：至少有一个资源必须处于非共享模式，即一次只能被一个线程使用。如果另一个线程请求该资源，那么请求线程必须等待，直到该资源被释放
2.请求与保持条件(Hold and Wait)：一个线程已经持有至少一个资源，并且正在等待获取其他被其他线程占用的资源
3.不可剥夺条件(No Preemption)：资源一旦被分配给某个线程，就不能被强制性地剥夺，只能由占有该资源的线程自行释放
4.环路等待条件(Circular Wait)：存在一个线程资源的循环等待链，其中每个线程都在等待下一个进程所持有的资源

预防死锁：通过破坏死锁的四个必要条件之一，可以预防死锁的发生

1.破坏互斥条件：尽量使用可共享的资源
2.破坏占有且等待：一次性申请所有需要的资源，避免部分持有
3.破坏非抢占条件(不建议)：允许系统强行剥夺某些进程已占有的资源，分配给其他进程。这种方法可能导致进程执行的不稳定性
4.破坏循环等待条件：对资源进行排序，按固定顺序申请资源

3.volatile

3.1 概念

volatile：是编程语言中的关键字，用于修饰变量，告知编译器该变量可能被意外修改。其核心作用是防止编译器优化导致的数据不一致问题(在Java中仅能修饰成员变量)

3.2 特性

3.2.1 内存可见性

对volatile变量的每次访问都会强制从主内存读取，每次修改都会立即写回主内存

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();
    }
}

3.2.2 禁止指令重排序

在多线程场景下，指令重排序可能会导致线程间数据同步问题。volatile变量通过插入内存屏障(Memory Barrier)来禁止重排序

读操作前插入“LoadLoad”屏障，读操作后插入“LoadStore”屏障

写操作前插入“StoreStore”屏障，写操作后插入“StoreLoad”屏障

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写操作之后
    }
	boolean demo = true
    // 读线程方法
    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
        }
    }
}

3.2.3 不保证原子性

volatile不保证操作的原子性，多线程环境下仍需结合锁或原子操作

4.wait/notify

概念：wait()和notify()是Java中用于线程间通信的机制，属于Object类的方法。它们必须在同步代码块(如synchronized块)中使用，否则会抛出IllegalMonitorStateException

wait(): 让当前线程进入等待状态，释放锁，直到其他线程调用notify()或notifyAll()唤醒它
notify(): 随机唤醒一个等待该对象锁的线程
notifyAll(): 唤醒所有等待该对象锁的线程

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();
    }
}

wait与sleep的区别

概念：
- wait是Object类的方法，用于线程间的通信，必须配合synchronized使用，调用wait的线程会释放锁
- sleep是Thread类的静态方法，用于暂停当前线程的执行，调用sleep的线程不会释放锁
锁的释放行为差异：
- wait会释放当前线程持有的锁，允许其他线程获取该锁并执行同步代码块，这一特性使得wait适用于多线程协作的场景
- sleep不会释放任何锁，即使线程休眠，其他线程也无法获取该线程持有的锁，这可能导致死锁或性能问题
唤醒机制：
- wait需要通过notify或notifyAll主动唤醒，否则线程会一直等待(可以设置最大等待时间)，唤醒后线程需要重新获取锁才能继续执行
- sleep无需外部唤醒，到达指定时间后自动恢复，恢复执行的线程直接从sleep调用处继续执行

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-10-20，如有侵权请联系 cloudcommunity@tencent.com 删除

volatile