Java GC 没有第二次收集“僵尸”对象

Question

我正在尝试创建一种机制来将对象缓存到内存中，以备将来使用，即使这些对象脱离上下文也是如此。将有一个并行的确定性过程，它将（通过唯一的 ID）指示缓存的对象是否应该再次检索或是否应该完全死亡。这是最简单的示例，带有调试信息以使事情变得更容易：

package com.panayotis.resurrect;

import java.util.Map;
import java.util.HashMap;

public class ZObject {

    private static int IDGEN = 1;

    protected int id;
    private boolean isKilled = false;

    public static final Map<Integer, ZObject> zombies = new HashMap<>();

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++)
            System.out.println("* INIT: " + new ZObject().toString());
        gc();
        sleep(1000);

        if (!zombies.isEmpty())
            ZObject.revive(2);

        gc();
        sleep(1000);

        if (!zombies.isEmpty())
            ZObject.kill(1);

        gc();
        sleep(1000);
        gc();
        sleep(1000);
        gc();
        sleep(1000);
        gc();
        sleep(1000);
    }

    public ZObject() {
        this.id = IDGEN++;
    }

    protected final void finalize() throws Throwable {
        String debug = "" + zombies.size();
        String name = toString();
        String style;
        if (!isKilled) {
            style = "* Zombie";
            zombies.put(id, this);
        } else {
            style = "*** FINAL ***";
            zombies.remove(id);
            super.finalize();
        }
        dumpZombies(style + " " + debug, name);
    }

    public String toString() {
        return (isKilled ? "killed" : zombies.containsKey(id) ? "zombie" : "alive ") + " " + id;
    }

    public static ZObject revive(int peer) {
        ZObject obj = zombies.remove(peer);
        if (obj != null) {
            System.out.println("* Revive      " + obj.toString());
            obj.isKilled = false;
        } else
            System.out.println("* Not found as zombie " + peer);
        return obj;
    }

    public static void kill(int peer) {
        int size = zombies.size();
        ZObject obj = zombies.get(peer);
        String name = obj == null ? peer + " TERMINATED " : obj.toString();
        zombies.remove(peer);
        dumpZombies("*   Kill " + size, name);
        if (obj != null)
            obj.isKilled = true;
    }

    private static void dumpZombies(String baseMsg, String name) {
        System.out.println(baseMsg + "->" + zombies.size() + " " + name);
        for (Integer key : zombies.keySet())
            System.out.println("*             " + zombies.get(key).toString());
    }

    public static void gc() {
        System.out.println("* Trigger GC");
        for (int i = 0; i < 50; i++)
            System.gc();
    }

    public static void sleep(int howlong) {
        try {
            Thread.sleep(howlong);
        } catch (InterruptedException ex) {
        }
    }
}

这段代码将创建 5 个对象，复活第一个，然后杀死第一个。我期待着

• 第一次复活后，由于对象还没有任何引用，通过 finalize 重新进入僵尸状态（它没有）

• 再次杀死一个对象后，再次通过finalize方法从内存中完全删除

换句话说，finalize 似乎只被调用了一次。我用这段代码检查了这不是 HashMap 对象的副产品：

package com.panayotis.resurrect;

import java.util.HashMap;

public class TestMap {

    private static final HashMap<Integer, TestMap> map = new HashMap<>();

    private static int IDGEN = 1;
    private final int id;

    public static void main(String[] args) {
        map.put(1, new TestMap(1));
        map.put(2, new TestMap(2));
        map.put(3, new TestMap(3));
        map.remove(1);
        System.out.println("Size: " + map.size());
        for (int i = 0; i < 50; i++)
            System.gc();
    }

    public TestMap(int id) {
        this.id = id;
    }

    protected void finalize() throws Throwable {
        System.out.println("Finalize " + id);
        super.finalize();
    }
}

那么，为什么会有这种行为？我正在使用 Java 1.8

编辑由于这不可能直接实现，有什么想法可以做到这一点吗？

Answer 1

你知道吗？

我认为您的陈述要求只需通过并发地图即可满足。

我正在尝试创建一种机制来将对象缓存到内存中，以备将来使用，即使这些对象脱离上下文也是如此。

那只是一个简单的map，以ID为key；例如

Map<IdType, ValueType> cache = new HashMap<>();

当您创建需要缓存的对象时，您只需调用cache.put(id, object)。它会一直缓存，直到您将其删除。

会有一个并行的确定性过程，它将（通过唯一的 ID）指示缓存的对象是应该再次检索还是应该完全死亡。

这是一个调用cache.remove(id)的线程（“并行确定性过程”）。

现在，如果您从缓存中删除了一个对象，并且它仍在其他地方使用（即它仍然可访问），那么它将不会被垃圾回收。但这没关系。但不应该！

---

但是finalize() 的那些东西呢？

据我所知，它根本不符合您的声明要求。您的代码似乎检测到注定要删除的对象，并使它们可以访问（您的zombies 列表）。这似乎与您的要求相反。

• 如果finalize() 的目的只是跟踪Zombie 对象何时被实际删除，那么finalize() 只会被调用一次，所以它不能这样做。但是，为什么finalize() 方法会将对象添加到zombie 列表中？

• 如果您的要求实际上是错误的，并且您真的试图创建“不朽”对象（即无法删除的对象），那么一个普通的Map 会做到这一点。只是不要删除对象的键，它会永远“活着”。

---

现在将缓存实现为普通映射可能会造成内存泄漏。有几种方法可以解决这个问题：

1234563有关详细信息，请参阅 javadocs。

• 您可以将缓存实现为HashMap<SoftReference<IdType>, ValueType>，并使用ReferenceQueue 删除其引用已被GC 破坏的缓存条目。 （请注意，当某个键不再强可达，并且内存不足时，GC 会破坏软引用。）

Answer 2

这正是指定的行为：

Object.finalize()

在为对象调用finalize 方法后，不会采取进一步的行动，直到 Java 虚拟机再次确定没有任何方法可以让尚未访问的任何线程访问该对象。死亡，包括其他准备完成的对象或类可能执行的操作，此时该对象可能会被丢弃。

finalize 方法永远不会被 Java 虚拟机为任何给定对象多次调用。

您似乎对finalize() 方法的作用有错误的理解。此方法不会释放对象的内存，声明一个自定义的重要finalize() 方法实际上是防止对象的内存被释放，因为它必须保存在内存中才能执行该方法和之后，直到垃圾收集器确定它再次变得无法访问。不再调用finalize() 并不意味着对象没有被释放，它意味着它会被释放而不再调用finalize()。

没有自定义finalize() 方法或具有“普通”终结方法（为空或仅由super.finalize() 对另一个普通终结器的调用组成）的类实例根本不会通过终结队列，并且两者都是，分配更快，回收更快。

这就是为什么你永远不应该尝试只为内存实现对象缓存，结果总是比 JVM 自己的内存管理效率低。但是，如果您正在管理一个真正昂贵的资源，您可以通过将其分成两种不同类型的对象来处理它，一个为应用程序提供 API 的前端，当应用程序不使用它时，它可能会被垃圾收集，以及描述实际资源的后端对象，应用程序不会直接看到它，并且可能会被重用。

这意味着资源足够昂贵，足以证明这种分离的重要性。否则，它就不是真正值得缓存的资源。

// front-end class
public class Resource {
    final ActualResource actual;

    Resource(ActualResource actual) {
        this.actual = actual;
    }
    public int getId() {
        return actual.getId();
    }
    public String toString() {
        return actual.toString();
    }
}
class ActualResource {
    int id;

    ActualResource(int id) {
        this.id = id;
    }

    int getId() {
        return id;
    }

    @Override
    public String toString() {
        return "ActualResource[id="+id+']';
    }
}

public class ResourceManager {
    static final ReferenceQueue<Resource> QUEUE = new ReferenceQueue<>();
    static final List<ActualResource> FREE = new ArrayList<>();
    static final Map<WeakReference<?>,ActualResource> USED = new HashMap<>();
    static int NEXT_ID;

    public static synchronized Resource getResource() {
        for(;;) {
            Reference<?> t = QUEUE.poll();
            if(t==null) break;
            ActualResource r = USED.remove(t);
            if(r!=null) FREE.add(r);
        }
        ActualResource r;
        if(FREE.isEmpty()) {
            System.out.println("allocating new resource");
            r = new ActualResource(NEXT_ID++);
        }
        else {
            System.out.println("reusing resource");
            r = FREE.remove(FREE.size()-1);
        }
        Resource frontEnd = new Resource(r);
        USED.put(new WeakReference<>(frontEnd, QUEUE), r);
        return frontEnd;
    }
    /**
     * Allow the underlying actual resource to get garbage collected with r.
     */
    public static synchronized void stopReusing(Resource r) {
        USED.values().remove(r.actual);
    }
    public static synchronized void clearCache() {
        FREE.clear();
        USED.clear();
    }
}

请注意，管理器类可能有任意方法来控制资源的缓存或手动释放，以上方法只是示例。如果你的 API 支持前端失效，例如在调用close()、dispose() 或类似名称后，可以立即显式释放或重用，而无需等待下一个 gc 循环。虽然 finalize() 只被调用了一次，但您可以在此处控制重用周期的数量，包括排队 0 次的选项。

这是一些测试代码

static final ResourceManager manager = new ResourceManager();
public static void main(String[] args) {
    Resource r1 = manager.getResource();
    Resource r2 = manager.getResource();
    System.out.println("r1 = "+r1+", r2 = "+r2);
    r1 = null;
    forceGC();

    r1 = manager.getResource();
    System.out.println("r1 = "+r1);
    r1 = null;
    forceGC();

    r1 = manager.getResource();
    System.out.println("r1 = "+r1);

    manager.stopReusing(r1);

    r1 = null;
    forceGC();

    r1 = manager.getResource();
    System.out.println("r1 = "+r1);
}
private static void forceGC() {
    for(int i = 0; i<5; i++ ) try {
        System.gc();
        Thread.sleep(50);
    } catch(InterruptedException ex){}
}

这很可能（System.gc() 仍然不能保证有效果）打印：

allocating new resource
allocating new resource
r1 = ActualResource[id=0], r2 = ActualResource[id=1]
reusing resource
r1 = ActualResource[id=0]
reusing resource
r1 = ActualResource[id=0]
allocating new resource
r1 = ActualResource[id=2]

Answer 3

您不应该实现 finalize 方法，因为 GC 只会为每个实例调用一次。

所以如果 GC 会找到要删除的对象，它会调用 finalize。然后它会再次检查是否有新的参考。它可能会找到一个并将对象保存在内存中。

在下一次运行时，同一个对象将再次没有任何引用。 GC 只会杀死它，它不会再次调用 finalize。