Java线程安全：披萨争夺战的终极解法

原创已于 2025-12-12 08:37:23 修改 · 255 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

于 2025-12-12 08:07:50 首次发布

哈哈，小白你好！今天咱们来聊聊Java里的“线程安全”——这玩意儿就像一群程序员在办公室里抢同一份披萨，如果没点规矩，最后可能谁都吃不上完整的，还弄一地碎屑！😄

简单说，线程安全就是当多个“线程”（你可以想象成一群小工人）同时操作同一个东西（比如一个共享变量）时，保证数据不乱套、不出错。Java里，如果代码没处理好线程安全，就会出现“竞态条件”（race condition），就像两个线程同时去改一个计数器，结果数字跳来跳去，比股票市场还刺激！

下面我带你一步步玩转线程安全，先来个“反面教材”，再给个“安全方案”。代码我都会详细解释，包你一看就懂！

1. 反面教材：线程不安全计数器

想象一下，有个计数器类，多个线程同时去增加它。如果不加防护，结果可能乱成一锅粥。来，看看代码：

public class UnsafeCounter {
    private int count = 0; // 共享变量，危险地带！

    // 增加计数器的方法
    public void increment() {
        count++; // 这行代码不是原子操作，多个线程同时执行会出问题
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        UnsafeCounter counter = new UnsafeCounter();
        
        // 创建两个线程，每个线程增加计数器1000次
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        // 启动线程
        thread1.start();
        thread2.start();
        
        // 等待线程结束
        thread1.join();
        thread2.join();
        
        // 理论上应该输出2000，但实际可能小于2000
        System.out.println("最终计数: " + counter.getCount()); // 输出可能像1998或1995，乱套了！
    }
}

问题解释：

count++ 这行代码看着简单，但背后是三个步骤：读取当前值、加1、写回新值。
如果线程A和线程B同时读取（比如都读到100），然后都加1（变成101），再写回，结果计数器只增加了1次，而不是2次！这就是竞态条件。
运行几次，你会看到输出值五花八门，绝对不到2000，证明线程不安全。

2. 安全方案：使用synchronized加锁

现在，咱们给计数器加个“门锁”，就像办公室的披萨只能一个人切一样。Java的synchronized关键字就是这把锁，保证同一时间只有一个线程能操作共享资源。

public class SafeCounter {
    private int count = 0;

    // 用synchronized修饰方法，保证同一时间只有一个线程执行这个方法
    public synchronized void increment() {
        count++; // 现在安全了！
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        SafeCounter counter = new SafeCounter();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("最终计数: " + counter.getCount()); // 稳稳输出2000，完美！
    }
}

安全解释：

synchronized 关键字在方法上加了锁。当一个线程执行increment()时，其他线程必须等待，避免了并发冲突。
现在count++是原子操作了（在锁的保护下），结果总是2000，线程安全达成！
注意：锁会增加开销，但为了数据一致性，这点代价值了。

3. 进阶玩法：使用AtomicInteger

如果你嫌锁太重，Java还提供了更轻量的工具，比如AtomicInteger，它用硬件级指令保证原子性，速度快得像闪电！

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0); // 原子类来也！

    public void increment() {
        count.incrementAndGet(); // 原子操作，无需锁
    }

    public int getCount() {
        return count.get();
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicCounter counter = new AtomicCounter();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("最终计数: " + counter.getCount()); // 还是2000，但效率更高！
    }
}

优势解释：