一、💡 一句话理解
核心结论
方法内的局部变量引用是线程私有的，但它指向的
HashMap对象仍可能被其他线程拿到。因此，不能只看
HashMap是不是写在方法里，而要看：多个线程是否会同时访问同一个HashMap对象，并且其中存在写操作。
二、🎯 这道题考察哪些知识点
2.1 主要考点
这道题表面上在问 HashMap，实际上是在考察候选人能不能找到“线程安全”的真正判断条件。
| 知识点 | 面试官想听什么 |
|---|---|
| 局部变量与方法形参 | 它们本身属于本次方法调用，不会被其他线程直接共享 |
| 引用与对象的区别 | 引用是局部的，不代表它指向的对象一定没有被共享 |
HashMap 的线程安全性 | HashMap 本身不提供并发修改保证 |
| 线程封闭 | 如果一个可变对象始终只被一个线程使用，通常不需要加锁 |
| 对象逃逸与共享 | 局部对象可能通过返回值、共享字段、回调或线程传出方法 |
| 并发访问的判断 | 关键是否有多个线程同时访问同一对象，并且其中存在写操作 |
| 并发容器与同步方案 | 真正需要共享修改时，应考虑 ConcurrentHashMap、外部锁或其他同步方案 |
2.2 面试时的分析顺序
面试官并不只是想听到“HashMap 不安全”。更完整的分析顺序是：
- 是否每次调用都创建新对象？
- 这个对象是否会逃逸到方法外？
- 多个线程是否会拿到同一个对象？
- 共享后是只读，还是存在并发写入？
- 如果存在并发写入，使用了什么同步方案？
这道题的真正考点
不是背诵“局部变量线程安全”，而是从对象是否共享、是否存在并发写入两个角度作出判断。
三、🧭 理论：局部变量安全，不等于对象一定安全
3.1 先分清“引用”和“对象”
看下面这行代码：
Map<String, Integer> map = new HashMap<>();它包含两个不同的东西：
| 内容 | 含义 | 是否直接共享 |
|---|---|---|
map | 局部变量，保存对象的引用 | 不会，局部变量属于当前方法调用 |
new HashMap<>() | 真正的 HashMap 对象 | 可能共享，要看这个引用有没有被传出去 |
Java 语言规范明确说明：局部变量和方法形参不会被线程共享。但如果局部变量保存的是引用，其他线程仍然可能通过另一个引用找到同一个对象。
线程 A 的局部变量 mapA ──┐
├──→ 同一个 HashMap 对象
线程 B 的局部变量 mapB ──┘mapA 和 mapB 都是各自线程的局部变量，但它们仍可以指向同一个对象。
3.2 HashMap 本身不保证线程安全
HashMap 是非同步容器。官方 API 文档说明：多个线程并发访问同一个 HashMap 时，如果至少一个线程对它进行结构性修改，就必须在外部进行同步。
所以，方法内的 HashMap 之所以经常能安全使用，不是因为 HashMap 突然变成了线程安全容器，而是因为通常只有当前线程能找到这个对象。这种做法叫作线程封闭（Thread Confinement）。
四、⚙️ 理论：怎样判断是否安全
4.1 每次调用都创建新对象，并且没有逃逸
public void calculate() {
// 每次方法调用都会创建一个新的 HashMap。
Map<String, Integer> map = new HashMap<>();
map.put("语文", 100);
map.put("数学", 90);
}两个线程同时调用 calculate() 时：
线程 A：map 引用 ──→ HashMap 对象 A
线程 B：map 引用 ──→ HashMap 对象 B两个线程修改的是两个不同的对象，不会发生对同一个 HashMap 的并发修改，因此通常不需要加锁。
4.2 对象逃逸，只代表“可能被共享”
对象逃逸是指：在方法中创建的对象，被方法外部保存或使用。常见方式包括：
- 存入实例字段或
static字段； - 作为方法返回值传出；
- 传给其他对象、回调或线程。
逃逸 ≠ 一定线程不安全
返回一个
HashMap本身不会立刻造成线程安全问题。只有当多个线程实际共享它，并发生未正确同步的读写或写写操作时，才会出现并发安全风险。
4.3 常见情况对照表
| 情况 | 判断 | 原因 |
|---|---|---|
每个线程都在方法内 new HashMap<>()，且不传出去 | 安全 | 每个线程操作不同的对象 |
局部变量引用了共享字段中的 HashMap | 不一定安全 | 局部引用仍指向共享对象 |
方法形参接收到一个共享 HashMap | 不一定安全 | 形参本身私有，它指向的对象可能共享 |
方法返回 HashMap，后续只由一个线程使用 | 安全 | 虽然逃逸，但没有并发访问 |
| 对象构建完成后被安全发布，各线程只读不写 | 通常安全 | 没有并发修改；仍需注意 Value 自身是否可变 |
多个线程同时修改同一个 HashMap | 不安全 | HashMap 不提供并发修改保证 |
多个线程通过正确方式修改同一个 ConcurrentHashMap | Map 操作安全 | 使用了专门的并发容器 |
4.4 看似是局部变量，实际上仍然共享
private final Map<String, Integer> sharedMap = new HashMap<>();
public void addScore(String subject, int score) {
// map 是局部变量，但它只是 sharedMap 的另一个引用。
// 多个线程调用此方法时，修改的仍是同一个 HashMap。
Map<String, Integer> map = sharedMap;
map.put(subject, score);
}这个例子说明：判断的对象是 HashMap 实例，而不是变量名字或变量声明的位置。
五、🚀 实践：从准备到验证
5.1 前置准备
- JDK 8 或更高版本；
- 无需引入第三方依赖。
5.2 可以拿来干什么
5.2.1 方法内组装临时数据
当 Map 只用来完成本次请求的计算、分组或返回值组装时，可以在方法内创建普通 HashMap。
public Map<String, Integer> buildScores() {
// 本次调用创建独立对象。
Map<String, Integer> scores = new HashMap<>();
scores.put("语文", 100);
scores.put("数学", 90);
return scores;
}输入是一次方法调用，输出是该次调用独立创建的 Map。返回后是否安全，要继续取决于调用方如何使用它。
5.2.2 保存多线程共享数据
如果业务本来就需要让多个线程共享并修改同一张 Map，可以根据业务语义选择 ../基础/2.ConcurrentHashMap 或外部锁。
// 这张 Map 明确需要被多个线程共享。
private final Map<String, Integer> scores = new ConcurrentHashMap<>();
public void addOne(String subject) {
// merge 对单个 Key 的合并操作由 ConcurrentHashMap 原子地完成。
scores.merge(subject, 1, Integer::sum);
}5.3 完整实践：代码、启动和验证
新建 ThreadLocalHashMapDemo.java，下面的程序会验证两件事：
- 两个线程调用同一个方法时，各自获得独立的
HashMap； - 确实需要共享并修改 Map 时，使用
ConcurrentHashMap。
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadLocalHashMapDemo {
// 这张 Map 明确由多个线程共享，所以使用并发容器。
private static final Map<String, Integer> SHARED_COUNTS =
new ConcurrentHashMap<>();
public static void main(String[] args) throws Exception {
// 创建两个工作线程，模拟方法被并发调用。
ExecutorService pool = Executors.newFixedThreadPool(2);
try {
Callable<Map<String, Integer>> task = () -> {
Map<String, Integer> localMap = buildScores();
// 共享计数表的修改使用 ConcurrentHashMap.merge。
SHARED_COUNTS.merge("completedTasks", 1, Integer::sum);
return localMap;
};
Future<Map<String, Integer>> futureA = pool.submit(task);
Future<Map<String, Integer>> futureB = pool.submit(task);
Map<String, Integer> mapA = futureA.get();
Map<String, Integer> mapB = futureB.get();
// false 表示两次方法调用创建了两个不同的 HashMap。
System.out.println("mapA 和 mapB 是同一个对象吗：" + (mapA == mapB));
System.out.println("mapA：" + mapA);
System.out.println("mapB：" + mapB);
System.out.println("已完成任务数：" + SHARED_COUNTS.get("completedTasks"));
} finally {
// 释放线程池资源，否则 JVM 可能不会立即退出。
pool.shutdown();
}
}
private static Map<String, Integer> buildScores() {
// 每次调用都执行 new，所以会得到一个独立的 HashMap。
Map<String, Integer> scores = new HashMap<>();
scores.put("语文", 100);
scores.put("数学", 90);
return scores;
}
}在源文件所在目录执行：
javac ThreadLocalHashMapDemo.java
java ThreadLocalHashMapDemo预期输出类似：
mapA 和 mapB 是同一个对象吗：false
mapA：{数学=90, 语文=100}
mapB：{数学=90, 语文=100}
已完成任务数：2Map 的遍历顺序可能不同，这不影响结论。关键是第一行为 false，而共享计数结果为 2。
常见误区
不要为了验证
HashMap不安全，就期待一段错误的并发代码每次都产生错误结果。并发问题通常具有偶发性；某次运行结果正确，不代表代码就是线程安全的。
六、📌 总结
- 局部变量和方法形参本身不会被线程共享。
- 局部引用指向的对象，仍然可能被多个线程共享。
- 每次调用都创建独立
HashMap，且不被其他线程拿到时，通常安全。 - 对象逃逸不等于立刻不安全；共享后发生未同步的并发写入，才是关键风险。
- 需要多线程共享并修改 Map 时，考虑 ../基础/2.ConcurrentHashMap、外部锁或其他同步方案。
一句话记忆
局部的是引用，不一定是对象；线程安全要看是否共享同一个可变对象。
七、🗣️ 面试时怎么回答
7.1 推荐回答
局部变量引用属于当前方法调用的栈帧，不同线程调用同一个方法时，会创建各自独立的栈帧，因此局部变量引用本身是线程私有的。
但是，引用是线程私有的，不代表它指向的对象一定是线程私有的。判断对象是否安全，关键要看多个线程能不能拿到同一个对象，以及是否存在并发写操作。
如果每次调用方法时都会执行
new HashMap<>()，并且这个对象没有通过返回值、实例字段、静态字段、共享容器或异步任务等方式逃逸，那么不同线程操作的是不同的HashMap实例，不会产生并发冲突。这属于线程封闭带来的安全，并不代表HashMap本身是线程安全的。如果局部变量只是引用了一个共享的
HashMap，或者方法中新建的HashMap被传给了其他线程，那么即使引用声明在方法内，也仍然可能发生线程安全问题。
7.2 时间紧张时的精简回答
方法内的局部引用属于当前调用的栈帧，是线程私有的；但引用指向的对象是否安全，要看对象有没有被多个线程共享。如果每次调用都创建新的
HashMap，并且对象没有逃逸，那么各线程操作的是不同实例，因此是安全的。这是线程封闭带来的安全，不代表HashMap本身是线程安全的。
7.3 面试官继续追问时
为什么局部变量是线程私有的？
每个线程都有自己的 Java 虚拟机栈。线程每调用一次方法，都会在自己的栈中创建一个栈帧，方法的局部变量保存在本次调用对应的局部变量表中，因此其他线程不能直接访问这个局部变量。
需要注意，不是“每创建一个线程就自动创建一个 map 引用”，而是线程实际调用并执行该方法时，才会创建对应的栈帧和局部变量。
什么叫对象逃逸？
对象逃逸是指在方法内创建的对象，被方法外部或其他线程获得。除了赋值给静态字段，还包括：
- 赋值给实例字段；
- 作为返回值返回；
- 放进共享容器；
- 传给回调或异步任务；
- 直接传给其他线程使用。
逃逸只说明对象具备了被共享的可能，并不等于一定不安全。真正需要警惕的是：多个线程同时访问同一个可变对象，并且至少有一个线程执行写操作。
堆是共享的，为什么堆里的对象还能是安全的？
“堆是线程共享的”表示对象通常分配在所有线程都可能访问的内存区域，但不代表每个线程都能自动找到堆里的所有对象。线程必须先持有对象的引用，才能访问该对象。如果一个对象的引用始终只存在于当前线程中，该对象虽然位于堆上，仍然可以通过线程封闭安全地使用。
面试表达重点
不要只说“局部变量在线程栈里，所以
HashMap是安全的”。应该强调：局部引用是私有的，对象是否安全取决于是否共享；没有共享同一个可变对象，才是这里安全的根本原因。