背景#

面试的时候遇到了一组关于进程、线程和线程安全的连续追问：

1. 什么是进程和线程？
2. 什么是线程安全？
3. 一个进程里的多个线程打开同一个文件，要不要关注线程安全？
4. 不关注会出现什么问题？
5. 多线程操作文件时，怎样保证线程安全？
6. 多个线程操作一个类的数据成员，要不要关注线程安全？
7. 函数的内部变量呢？
8. 没加锁就一定不安全吗？
9. 一个没有属性和方法的 Java 类，实例大小会不会是 0？

这些问题看起来比较散，其实考察的是同一条主线：

数据属于谁、数据存在哪里、数据是否被共享，以及多个线程同时访问共享数据时有什么保证。

回答这类问题时可以从操作系统、JVM 和 JMM 三个层面展开，但要注意它们解决的问题并不相同：

进程和线程#

从 JVM 看线程之间共享了什么#

JVM 运行时数据区域中，有些是线程共享的，有些是线程私有的。

JMM 是什么#

JMM，全称 Java Memory Model，即 Java 内存模型。它不是 JVM 堆、栈、方法区那张内存结构图，也不是一块真实存在的内存。

JMM 是一组并发语义规范，它主要规定：

• 一个线程对共享变量的修改，什么时候能被其他线程看到
• 多个读写操作能否被重排序
• 哪些操作具有原子性
• 什么样的同步关系能够建立 happens-before

理解线程安全时，通常需要关注三个性质。

1
读取 count
2
count 加 1
3
写回 count

什么是线程安全#

线程安全不是简单的“代码加了锁”，而是：

一段代码或一个对象被多个线程同时使用时，不需要调用方额外进行错误的时序假设，程序仍然能保持正确结果和合法状态。

判断是否需要关注线程安全，可以先问两个问题：

1. 数据是否会被多个线程共享？
2. 是否至少有一个线程会修改它？

如果两个答案都是“是”，通常就需要考虑线程安全。

1
共享 + 可变 + 并发访问 = 需要重点关注线程安全

如果数据不共享，或者共享数据永远不修改，一般就不需要为了它加锁。

多个线程打开同一个文件，需要关注线程安全吗#

答案不是一律需要或者一律不需要，要看具体操作。

File、Path 只是对文件路径的抽象。多个线程各自“打开文件”以后，可能拥有不同的流或文件描述符，但它们最终操作的仍然可能是磁盘上的同一份数据。所以即使没有共享同一个 Java 对象，也可能共享同一个外部资源。

1
读取余额文件，得到 100
2
在原值上增加 10
3
把 110 写回文件

多线程操作文件，怎样保证安全#

1
public class SafeFileStore {
2
    private final Object lock = new Object();
3
    private final Path path;
4

5
    public SafeFileStore(Path path) {
6
        this.path = path;
7
    }
8

9
    public String read() throws IOException {
10
        synchronized (lock) {
11
            return Files.readString(path);
12
        }
13
    }
14

15
    public void write(String content) throws IOException {
16
        synchronized (lock) {
17
            Files.writeString(path, content);
18
        }
19
    }
20
}

1
try (FileChannel channel = FileChannel.open(
2
        path,
3
        StandardOpenOption.CREATE,
4
        StandardOpenOption.WRITE);
5
     FileLock ignored = channel.lock()) {
6
    // 在持有文件锁期间读写
7
}

1
多个业务线程 -> BlockingQueue -> 单个写文件线程

类的数据成员需要关注线程安全吗#

需要看这个类的实例是否被共享，以及成员是否可变。

1
public class Counter {
2
    private int count;
3

4
    public void increment() {
5
        count++;
6
    }
7
}

如果一个 Counter 实例被多个线程共享，多个线程同时调用 increment()，count++ 会产生竞态条件，所以它不是线程安全的。

可以使用 synchronized：

1
public synchronized void increment() {
2
    count++;
3
}

也可以使用原子类：

1
private final AtomicInteger count = new AtomicInteger();
2

3
public void increment() {
4
    count.incrementAndGet();
5
}

但下面这些情况通常不需要因为该成员额外加锁：

• 每个线程只使用自己独立创建的对象
• 对象创建后不再修改，是不可变对象
• 对象被限制在单个线程中，没有发布给其他线程

还要注意 static 字段属于类级别，天然更容易被多个实例和线程共同访问。

final 可以防止字段引用被重新赋值，也能提供一定的安全发布语义，但不代表引用指向的对象一定不可变：

1
private final List<String> names = new ArrayList<>();

这里不能把 names 改成另一个 List，但多个线程同时修改这个 ArrayList 仍然可能不安全。

函数内部变量需要关注线程安全吗#

普通局部变量一般是线程私有的。

1
public int addOne(int value) {
2
    int result = value + 1;
3
    return result;
4
}

多个线程同时调用 addOne 时，每次方法调用都有自己的栈帧，每个线程操作自己的 value 和 result，互不影响，所以不需要加锁。

但是“变量本身是局部变量”不等于“它指向的对象一定线程私有”。

1
public void addName(List<String> names) {
2
    List<String> local = names;
3
    local.add("Java");
4
}

local 这个引用变量属于当前方法调用，是线程私有的；但它和参数 names 指向的 List 可能是多个线程共享的。多个线程同时调用这个方法并传入同一个 ArrayList，仍然有线程安全问题。

同样，方法内部如果访问成员变量、静态变量、共享缓存或文件，也不能因为方法里定义了局部变量就判断它是线程安全的。

1
private int count;
2

3
public void increment() {
4
    int next = count + 1; // next 是局部变量，但 count 是共享成员变量
5
    count = next;
6
}

没有加锁就一定不安全吗#

不一定。

锁只是保证线程安全的一种技术，不是判断线程安全的标准。以下方案都可能在不使用传统互斥锁的情况下保证安全：

• 不共享数据，使用线程封闭
• 使用不可变对象
• 使用 AtomicInteger 等原子类
• 使用 ConcurrentHashMap 等并发容器
• 使用 volatile 保证特定场景下的可见性和有序性
• 通过消息队列把共享写操作交给单一线程

反过来，代码中出现了锁也不代表一定正确。例如不同线程锁住了不同对象、锁的范围没有覆盖完整复合操作，仍然可能不安全。

还要特别注意，volatile 不能替代所有锁。它可以保证变量的可见性和特定的有序性，但不能让 count++ 这种复合操作整体变成原子操作。

1
private volatile int count;
2

3
public void increment() {
4
    count++; // 仍然不是线程安全的
5
}

Java 空对象的大小会不会是 0#

不会。

1
public class Empty {
2
}
3

4
Empty empty = new Empty();

虽然 Empty 没有定义实例字段和方法，但实例仍然需要对象头。对象头通常需要记录或关联这些信息：

• 运行时类型信息
• GC 年龄、哈希码、锁状态等 Mark Word 信息
• 数组对象还需要额外记录数组长度

另外 JVM 通常还会按照一定字节数进行内存对齐。因此空对象的实例大小不可能是 0。

在常见的 64 位 HotSpot JVM、开启压缩类指针、对象按 8 字节对齐的情况下，一个普通空对象通常可以这样估算：

1
Mark Word：8 字节
2
类型指针：4 字节
3
实例字段：0 字节
4
对齐填充：4 字节
5
总计：16 字节

这个 16 字节 不是 Java 语言规范规定的固定答案。关闭压缩指针、更改对象对齐方式、使用不同 JVM 实现时，结果可能不同。实际分析可以使用 JOL（Java Object Layout）查看。

1
System.out.println(ClassLayout.parseInstance(new Empty()).toPrintable());

还要区分引用变量大小和对象实例大小：

1
Empty empty = new Empty();

empty 是引用，new Empty() 才是堆中的对象实例。引用本身通常是 4 字节或 8 字节，取决于 JVM 位数和是否开启压缩普通对象指针；类元数据也不会在每个实例中完整复制一份。

面试时可以怎样回答#

可以先给出一个判断框架：

进程是资源分配和隔离的重要单位，线程是进程内的执行和调度单位。同一进程里的线程共享堆和外部资源，每个线程有自己的栈和程序计数器。只要存在共享、可变数据，并且会被并发访问，就要关注线程安全。JVM 内存区域告诉我们数据大致在哪里，JMM 则通过原子性、可见性、有序性和 happens-before 规则规定多线程读写的语义。

然后再根据追问落到具体对象：

• 文件：即使每个线程使用不同的流，底层也可能操作同一个外部资源；并发写要考虑覆盖、交叉写和读取半成品，可以使用同一把 JVM 锁、文件锁、单写线程队列或原子替换
• 成员变量：同一个实例被多线程共享并且字段可变时需要关注；不同实例或不可变对象通常不需要
• 局部变量：每次调用的普通局部变量属于各自栈帧，通常安全；但局部引用指向的对象仍然可能共享
• 是否加锁：不能只看有没有 synchronized，还可以通过不可变、线程封闭、原子类和并发容器实现线程安全
• 空对象：实例大小不会为 0，因为至少有对象头和内存对齐；常见 HotSpot 配置下一般是 16 字节，但应以实际 JVM 配置为准

总结#

这一组问题真正想考察的不是能否背出“堆共享、栈私有”，而是能不能沿着下面的顺序分析：

1
数据在哪里
2
    ↓
3
是否被多个线程共享
4
    ↓
5
是否会发生修改
6
    ↓
7
一次业务操作是不是原子的
8
    ↓
9
线程之间有没有可见性和有序性保证
10
    ↓
11
应该使用锁、原子类、不可变对象、线程封闭，还是改变整体设计

JVM 的堆栈结构是分析的起点，JMM 是解释并发语义的工具，但具体到文件时，还必须继续考虑操作系统和文件系统。把这几个层面分清楚，再遇到类似的追问，就不会只停留在“共享变量要加锁”这一句话上。