面试题：符合垃圾回收条件的对象

Question

给出以下代码：

class A {
    Boolean b;
    A easyMethod(A a){
        a = null;
        return a;
    }
    public static void main(String [] args){
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
        a3 = a1.easyMethod(a2);
        a1 = null;
        // Some other code 
    }
}

问题是在// Some other code 之前有多少对象可以进行垃圾回收。

那么正确答案是（至少这是面试官的答案）：2 - 布尔值 b，因为它是一个包装器和 a1。

你能解释一下为什么a2 和a3 没有被垃圾收集吗？

稍后编辑：

• 好的，我想我现在明白了。一开始有点困惑，但现在我确定面试官错了。我最初的错误是，一开始我没有考虑到 Java 只是按值传递，所以不可能从以“a2”作为参数的函数内部使 a2 为空，因为 a2 实际上是 a2 的副本。
• 带有布尔b的部分确实很明显。

感谢您的回答，之后我会发送一些面试反馈:)。

Answer 1

提供a1.go(a2)实际上是a1.easyMethod(a2)，答案确实是2，但不是你列出的那些。正如 Bozho 正确指出的那样，b 未初始化，因此它不引用任何对象。在评论处符合垃圾回收条件的两个对象是 a1 和 a3 最初引用的对象。

a1 显然被清空了，a3 被重新赋值给a1.easyMethod(a2) 的返回值，即为空。但是，a2 不受方法调用的影响，如Java is pass by value，因此只有引用a2 的副本被传递给方法。即使副本设置为 null，也不会影响原始 a2 的值。

Answer 2

假设 go 应该是 easyMethod 它是这样工作的

class A {
    Boolean b;
    A easyMethod(A a){
        a = null; // the reference to a2 was passed in, but is set to null
                  // a2 is not set to null - this copy of a reference is!
        return a; // null is returned
    }
    public static void main(String [] args){
        A a1 = new A(); // 1 obj
        A a2 = new A(); // 2 obj
        A a3 = new A(); // 3 obj
        a3 = a1.go(a2); // a3 set to null and flagged for GC - see above for why
        a1 = null; // so far, a1 and a3 have been set to null and flagged
        // Some other code 
    }
}

有两个对象可以进行垃圾回收（a1 和 a3）。 b 不是因为它只是对 null 的引用。从未制作过Boolean。

为了解决// Some other code 可能存在的微妙之处，我将问题改写为以下内容：

预测并解释以下输出：

class A {
    int i;
    A(int i) { this.i = i; }
    public String toString() { return ""+i; }
    A go(A a){
        a = null; // the reference to a2 was passed in, but is set to null
                  // a2 is not set to null - this copy of a reference is!
        return a; // null is returned
    }
    public static void main(String [] args){
        A a1 = new A(1); // 1 obj
        A a2 = new A(2); // 2 obj
        A a3 = new A(3); // 3 obj
        a3 = a1.go(a2); // a3 set to null and flagged for GC - see above for why
        a1 = null; // so far, a1 and a3 have been set to null and flagged

        test(a1);
        test(a2);
        test(a3);

    }
    static void test(A a) {
        try { System.out.println(a); } 
        catch(Exception e) { System.out.println((String)null); }
    }
}

然后输出：

c:\files\j>javac A.java

c:\files\j>java A
null
2
null

接下来是，此时 a1 和 a3 符合 GC 条件，而 a2 则没有。

这个问题的教训是“将对象引用传递给方法并将该引用设置为 null 不会导致原始引用为 null”。这就是面试官试图测试的知识。

Answer 3

首先面试官对布尔值的理解是错误的——这段代码没有创建这样的对象，所以没有什么可以被垃圾收集。

将b 和a2 等变量 称为垃圾回收是不正确的。对象是垃圾收集的，而不是变量。如果一个范围内的变量引用了一个对象，那么它就不能被垃圾回收。简单地说，只有当一个对象不再被任何变量引用时，它才能被垃圾回收。

所以我们在这段代码中创建了三个 A 实例。它们最初由a1 等引用，但由于变量引用发生了变化，我将对象实例称为A1、A2 和A3。由于您没有显示go 方法的定义，我将假设它是对easyMethod 的调用。

由于变量 a1 被重新赋值为 null，因此没有任何东西指向实例 A1，因此它可以被垃圾回收。

由于变量 a2 永远不会重新分配（easyMethod 中的分配不会影响原始变量），因此无法对实例 A2 进行垃圾回收。

由于easyMethod 总是返回null 并且a3 被分配了该方法的结果，所以没有任何东西指向实例A3，所以它也可以被垃圾回收。

Answer 4

你能解释一下为什么 a2 并且 a3 没有被垃圾收集 ?

因为 a2 和 a3 不是对象。它们是变量。变量不可收集，原因很简单，它们不可分配。

Answer 5

对于 a2 的原始引用，它实际上完全取决于“其他代码”中发生的情况。如果“其他代码”不使用 a2 或 a3，则原始 a2 对象有资格进行垃圾回收。

这是因为运行时不必关心 lexical 范围。它只需要知道一个对象永远不会被再次引用。因此，如果“一些其他代码”不使用 a2 或 a3，则它们指向的对象永远不会被再次引用，因此已经可用于垃圾回收。

Answer 6

你的问题很困惑。

垃圾收集器处理对象，而不是变量。 因此，当您说 a2 有资格获得 GC 时，它没有任何意义。 你应该说在第 N 行被 a2 引用的对象在第 N+M 行符合 GC 条件。

在您的示例中，您只有 3 个被实例化的对象。符合 GC 条件的是第一个 create A 和最后一个 create A 实例。

Answer 7

问题是在// Some other code. 之前有多少对象可以进行垃圾回收

这个问题很荒谬。

垃圾收集器在运行时处理那里可用的信息。可达性由存储在寄存器、线程堆栈和全局变量中的全局根决定。寄存器和堆栈的内容是完全破坏代码的许多编译阶段的结果。源代码中的词法范围和行号的概念不再存在，因此询问 GC 可能在源代码中的某些点看到什么是无意义的，因为这些点在 GC 的世界中不存在。

因此，我们必须首先假设源代码和生成的代码之间存在直接对应关系，否则我们甚至无法理解问题所指的代码点。我想不出有任何工作的虚拟机在实践中真正做到这一点，事实上，Java 可能具有甚至无法以这种方式编译为字节码的高级语言结构。

接下来，我们必须假设一个模型用于将本地引用保存在堆栈中的方式。与其假设一些定义不明确的模型来得出随机答案，我将证明模型的选择允许我们得出从“没有任何东西符合 GC”到“一切都符合 GC 的条件”的答案。这一系列合理的答案确实突出了这个问题的糟糕程度。

考虑一个简单的模型，其中中间值（所有子表达式以及变量的结果）被压入堆栈直到函数结束。简单的编译器和虚拟机（如 Windows Phone 7 上的 HLVM 和 .NET）在实践中实际上是这样工作的，尽管这会保留引用的时间超过必要的时间。使用此模型，每个new A() 都会将一个引用推入堆栈，直到函数返回，因此所有三个都可以从堆栈中的相关点访问，因此没有任何内容符合垃圾回收的条件。

考虑一个模型，其中引用从堆栈中删除的第一个点不再读取它们。这更接近于生产虚拟机（如 .NET 和 OCaml）的工作方式，只是它们尽可能将本地引用保存在寄存器中，否则会溢出到函数调用堆栈帧中的预分配条目，覆盖死局部变量以最小化堆栈帧的大小。使用此模型，所有引用在相关点都已失效，因此无法访问，因此，所有三个新分配的对象以及 args 数组及其引用的所有字符串都符合垃圾回收条件。

因此，我们不仅证明了从 nothing 到 everything 的答案是合理的，而且我们甚至引用了实现这些模型的真实工作虚拟机和垃圾收集器，因此我们的预测是可测试的。

如果我在面试中被问到这个问题，我会通过解释其中的一些来测试面试官。如果他们通过表达对学习的兴趣反应良好，那么我仍然会对这份工作感兴趣。如果他们试图为自己定义不明确的假设和无法检验的预测辩护而反应不佳，那么我不想与他们合作。