本文从线程内存模型出发，讲解跨线程变量访问的底层规则，以及为什么多线程代码中必须用引用类型而不能用基本类型。

---

一、问题复现：子线程能操作主线程的局部变量吗？

先看一段代码：

public static void main(String[] args) {
    int count = 0; // 主线程的局部变量

    Thread t1 = new Thread(() -> {
        count++; // ❌ 编译错误：Variable used in lambda should be final or effectively final
    });
    t1.start();
}

编译器直接报错，不让改

"Lambda 变量必须是 final"只是现象，真正原因在于线程的内存结构。

---

二、根本原因：每个线程拥有独立的栈

回顾 JVM 内存模型：

JVM 内存
├── 方法区（Method Area）—— 存类信息、静态变量，线程共享
├── 堆（Heap）—— 存对象实例，线程共享
└── 栈（Stack）—— 每个线程独立一份，互不可见
    ├── 主线程栈：main() 栈帧 → [count=0, t1=引用]
    ├── t1 线程栈：run() 栈帧 → [独立空间]
    └── t2 线程栈：run() 栈帧 → [独立空间]

关键结论：局部变量存在于栈中，而每个线程的栈是独立且私有的。

主线程的 count 存在于主线程的栈帧中。子线程 t1 有自己的栈，它无法直接访问主线程栈中的数据。

---

三、Java 对跨线程访问的处理：隐式加 final

Java 给出的解决方案是：

子线程代码中，所有来自外部（主线程）的变量，对该子线程而言，相当于隐式加了 final。

这意味着：

• 子线程可以读主线程的变量（拷贝一份只读副本）
• 子线程不能修改主线程的变量

int count = 0;

Thread t1 = new Thread(() -> {
    System.out.println(count); // ✅ 可以读
    count = 1;                 // ❌ 不允许修改，相当于修改 final 变量
});

为什么这样设计？因为如果允许子线程直接修改主线程栈中的变量，就会产生严重的数据竞争问题——两个线程同时操作同一块栈内存，后果不可控。

---

四、final 关键字的完整语义

要理解跨线程访问限制，需要先掌握 final 的所有语义：

修饰目标	效果
类	不可被继承
方法	不可被子类重写
基本类型变量	不能第二次赋值
引用类型变量	不能改变引用指向（但可以修改对象内部的属性）

⚠️ 最容易混淆的一点：final 修饰引用类型，限制的是"指向不能变"，而不是"对象内部不能变"。

final int[] arr = {1, 2, 3};
arr[0] = 99;       // ✅ 合法：修改的是数组内部的元素，没有改变 arr 的指向
arr = new int[5];  // ❌ 非法：改变了 arr 的引用指向

final StringBuilder sb = new StringBuilder("hello");
sb.append(" world"); // ✅ 合法：修改的是 sb 对象内部状态
sb = new StringBuilder(); // ❌ 非法：改变了 sb 的引用指向

另外，final 还有一个鲜为人知的功能：具备一定的防止指令重排序能力，类似于 volatile 的部分语义（禁止特定的重排序），这在并发编程中也有重要意义。

---

五、为什么必须用引用类型？

理解了上面两点，就能推导出答案了：

场景：子线程需要对某个计数器做加法操作。

尝试一：基本类型 ❌

int count = 0; // 基本类型，存在主线程栈中

Thread t1 = new Thread(() -> {
    count++; // ❌ 报错！相当于修改 final 基本类型，不允许二次赋值
});

基本类型的"修改"意味着对这个变量本身赋一个新值（count = count + 1），这相当于对 final 变量二次赋值，被编译器直接拒绝。

尝试二：引用类型 ✅

// 用一个对象包装 count
class Counter {
    public volatile int flag = 0;
}

Counter x = new Counter(); // 引用类型，x 指向堆中的对象

Thread t1 = new Thread(() -> {
    x.flag++; // ✅ 合法！没有改变 x 的指向，只是修改了对象内部的属性
});

Thread t2 = new Thread(() -> {
    x.flag++; // ✅ 合法！同上
});

为什么这样可以？

• x 是引用变量，隐式加了 final，意味着不能改变 x 的指向
• x.flag++ 操作的是 x 所指向的对象（在堆上）的内部属性，并没有改变 x 的指向
• 堆内存是所有线程共享的，子线程当然可以访问

主线程栈                  堆（所有线程共享）
┌──────────┐             ┌──────────────────┐
│ x ──────────────────→  │ Counter 对象      │
│ (final,  │             │ flag = 0          │
│  不能改   │             │                  │
│  变指向)  │             └──────────────────┘
└──────────┘                    ↑       ↑
                          t1 可读写   t2 可读写

这就是为什么多线程场景下，需要通过引用类型（对象、数组）来共享可变数据。

---

六、用数组也可以

除了自定义对象，数组也是引用类型，同样适用：

int[] count = {0}; // 数组是引用类型

Thread t1 = new Thread(() -> {
    count[0]++; // ✅ 修改的是数组内部元素，不是 count 的指向
});

但实际开发中更推荐使用 AtomicInteger 等原子类，语义更清晰，线程安全性更有保障。

---

七、改变引用指向会怎样？

明确了规则，我们再看反面案例：

Counter x = new Counter();

Thread t1 = new Thread(() -> {
    x = new Counter(); // ❌ 编译错误：改变了 x 的引用指向
});

无论是基本类型还是引用类型，只要是改变变量本身（基本类型赋新值，引用类型换指向），都属于对"隐式 final 变量"的修改，编译器不允许。

---

八、其他问题

Q1：Lambda 中为什么只能使用 effectively final 的变量？

因为子线程与主线程有独立的栈结构，子线程无法直接操作主线程栈中的数据。Java 将外部变量对子线程隐式加了 final，只允许读取，不允许修改。这是 JVM 线程内存模型决定的，不是语法的随意限制。

Q2：多线程代码中为什么要把共享变量放在对象里？

因为基本类型变量存在栈中，子线程无法修改；而对象实例存在堆中，堆是所有线程共享的。通过引用类型，子线程可以在不改变引用指向的前提下，修改对象内部的属性，从而实现跨线程的数据共享和修改。

Q3：final 修饰引用类型时，内部属性可以修改吗？

可以。final 只限制引用本身不能指向新的对象，不限制对象内部状态的变化。

Q4：以下代码哪行会报错？

final int[] arr = {1, 2, 3};
arr[0] = 100;      // A
arr = new int[3];  // B

B 行报错。A 行是修改数组元素（对象内部），合法；B 行是改变 arr 的引用指向，违反 final 限制。

---

九、小结

情况	子线程能否修改	原因
主线程的基本类型局部变量	❌ 不能	存在栈中，隐式 final，不可二次赋值
主线程的引用类型（改变指向）	❌ 不能	隐式 final，不可改变引用指向
主线程引用类型对象的内部属性	✅ 可以	对象在堆上，堆是线程共享的
静态变量	✅ 可以	在方法区，所有线程共享
实例变量（对象属性）	✅ 可以	在堆上，所有线程共享