Java多线程：理解并发执行与线程安全

多线程是 Java 学习中既重要又容易出问题的一部分。它能提升程序对并发任务的处理能力，但也会带来可见性、竞态条件、死锁等一系列复杂问题。

如果说普通语法知识是在教你“怎么写程序”，那么多线程更像是在教你“程序同时做很多事时会发生什么”。真正的难点不在于“会不会启动线程”，而在于“多个执行单元同时运行时，程序结果是否还可靠”。

一、为什么程序需要多线程

当程序需要同时处理多个任务时，多线程可以提升响应能力。例如：一个线程处理网络请求，另一个线程写日志，还有线程负责后台定时任务。

对于桌面程序来说，多线程可以避免界面卡死；对于服务端程序来说，多线程可以提升吞吐能力；对于批处理任务来说，多线程可以缩短整体执行时间。

不过，多线程不是越多越好。线程切换本身有成本，线程之间还可能发生资源竞争，因此必须带着问题去使用，而不是为了“看起来高级”。

二、进程、线程和并发到底是什么关系

初学多线程时，最好先把这几个概念区分开：

进程：操作系统进行资源分配的基本单位；
线程：进程中的执行单位，同一进程内的线程共享内存空间；
并发：多个任务在一段时间内交替推进；
并行：多个任务在同一时刻真正同时执行。

从 Java 程序员的角度看，线程之间共享堆内存，这正是多线程既强大又危险的根源。共享数据让协作更方便，也让冲突更容易发生。

三、线程安全问题通常从哪里来

只要多个线程同时访问和修改同一份共享数据，就可能出现竞态条件。最典型的表现就是结果偶尔正确、偶尔错误，而且错误很难稳定复现。

例如一个自增操作 count++，看起来只有一行，但底层往往不是一个原子动作。它通常至少包含：

读取当前值；
加一；
写回新值。

如果多个线程同时执行这三个步骤，中间就可能发生覆盖，导致最终结果比预期小。这类问题就叫竞态条件。

也正因为如此，多线程 bug 往往比普通 bug 更难排查。你看到的表面现象，未必就是问题真正发生的位置。

四、Java 多线程里最核心的几个问题

学习多线程时，至少要反复建立这三个意识：

1. 原子性

某个操作要么完整执行，要么完全不执行，中间不能被打断。像 i++ 这种复合操作，通常就不具备天然原子性。

2. 可见性

一个线程修改了共享变量后，其他线程能不能马上看到最新值？如果不能，就会出现“明明改了但另一边像没改一样”的现象。

3. 有序性

编译器、CPU 和运行时为了优化性能，可能会调整部分指令执行顺序。如果没有正确的同步约束，多线程环境里这种重排序可能带来意外结果。

这三个词几乎是所有并发问题的底层关键词。后面理解 synchronized、volatile、锁和并发工具类时，都绕不开它们。

五、Java 提供了哪些基础并发能力

synchronized 用来做基础同步，volatile 主要保证可见性，Lock 提供更灵活的锁控制，线程池则用于统一管理任务执行。

学习多线程时，不要只记工具名字，更要理解这些工具分别在解决什么问题。

1. synchronized

synchronized 是 Java 最基础的同步机制。它可以让同一时刻只有一个线程进入某段临界区代码，从而避免多个线程同时修改共享状态。

它解决的核心问题是：

保证同一时间只有一个线程执行关键代码；
让进入和退出同步块的线程之间建立可见性关系。

2. volatile

volatile 不能代替锁，它更适合用来保证变量的可见性，以及在一定程度上约束指令重排序。它适用于“一个线程写，多个线程读，且操作本身较简单”的场景。

如果你要做复合操作，如“判断后再修改”，单靠 volatile 往往不够。

3. Lock

Lock 接口相比 synchronized 更灵活，常见的如 ReentrantLock，可以支持显式加锁解锁、尝试加锁、可中断获取锁等能力。

实际开发中，如果只需要简单同步，synchronized 已经足够；如果需要更细粒度控制，Lock 会更适合。

4. 线程池

频繁创建和销毁线程成本不低。线程池的核心价值，是复用线程、控制并发数量、统一调度任务。服务端开发里，线程池几乎是必须理解的内容。

六、一个最简单的线程创建示例

public class Main {
    public static void main(String[] args) {
        Runnable task = () -> System.out.println(Thread.currentThread().getName());
        new Thread(task, "worker-1").start();
        new Thread(task, "worker-2").start();
    }
}

这个例子只是一个起点。真正的多线程学习重点，不在于“能不能启动线程”，而在于多个线程同时操作数据时，结果是否仍然可靠。

如果你再进一步写一个多个线程共同累加计数器的小实验，就会很快发现：没有同步措施时，结果往往不稳定。这种实验非常适合帮助自己建立并发直觉。

七、线程池为什么比频繁 new Thread 更重要

在真实项目里，直接频繁 new Thread() 往往不是好习惯，原因包括：

线程创建和销毁有成本；
线程数量失控会带来调度压力；
缺少统一管理，不利于监控和排障；
高并发下容易把系统资源耗尽。

线程池则可以：

控制同时运行的线程数；
排队等待任务执行；
复用已创建的线程；
统一管理拒绝策略、线程命名、异常处理。

所以从工程角度看，多线程的重点通常不是“怎么开线程”，而是“怎么管理线程”。

八、多线程里最常见的几个风险

1. 竞态条件

多个线程同时修改共享数据，导致结果不可预测。

2. 死锁

多个线程互相等待对方释放资源，最后谁也走不下去。最常见的情况是：线程 A 持有锁 1 等锁 2，线程 B 持有锁 2 等锁 1。

3. 活锁

线程没有真正阻塞，但彼此不断让步，结果谁都无法推进。

4. 饥饿

某些线程长期拿不到执行机会或关键资源，导致一直无法完成任务。

这些问题不一定会在简单练习里立刻暴露，但在真实系统里都非常典型。越早建立这些风险意识，后面越不容易把并发问题想得过于轻松。

九、学习和实践中的注意事项

不要把“能跑起来”误认为“线程安全”。
能减少共享状态时，往往比到处加锁更重要。
不要一开始就把所有并发问题都交给复杂框架，先自己理解底层模型。
出现并发 bug 时，优先怀疑共享变量、锁顺序、可见性和线程池配置。
写并发代码时，要先画出数据流和资源访问关系，再下手实现。

十、实践建议

先通过小实验观察线程交替执行的结果，再学习同步机制。
练习 synchronized、volatile、Lock 时，要明确它们各自解决的问题边界。
从“多个线程操作一个共享变量”的实验开始，再逐步过渡到线程池和生产者消费者模型。
学多线程时，不只看语法，更要持续问自己：共享数据在哪里、谁在写、谁在读、有没有同步约束。

总结

多线程的学习重点，不是只会创建线程，而是理解并发带来的复杂性：共享数据、同步、可见性、调度和线程池。只有把“为什么会乱”想明白，才能真正写出可靠的并发代码。

从入门到进阶，你至少要逐步建立这些认知：

线程安全问题通常来自共享状态；
synchronized、volatile、Lock 解决的问题并不一样；
真正的工程重点往往在线程池和任务管理，而不是手动创建线程；
并发 bug 最难的地方，是它不稳定、难复现、难定位。

把这些底层思路打牢，后面学习并发包、线程池参数、并发容器和高性能框架时，你会轻松很多。

参考资源：