Over a million developers have joined DZone.

Object Resurrection

DZone's Guide to

Object Resurrection

· Java Zone
Free Resource

Are you joining the containers revolution? Start leveraging container management using Platform9's ultimate guide to Kubernetes deployment.

After an object which overrides finalize() is collected it is added to a finalization queue to be cleaned up after calling the finalize() method of each object.  By what happens if you resurrect the object?

When is finalize called?

The finalize method is called by a single threaded system task which calls this method for each object which has been collected. Note: the nodes in the finalization queue are objects also have finalize() methods notionally. Objects cannot be cleaned up until the GC after they have been finalized.

Most objects (including the node in the finalization queue) don't overriden finalize() and so the GC is smart enough to detect this and not add them to the queue. These obejcts can be cleaned up immediately. If you override the method, even with an empty one, it makes a difference.

What about resurrected objects?

In the finalize() method, you can resurrect the object by giving making something point to it. e.g. a static collection.  This object can no longer be collected by a GC (until it is discarded again)  So what happens then? 

The object has been flags as being finalized once and is not finalized repeatedly.
 static final List ZOMBIES = new ArrayList<>();
    static class Zombies {
        private int num;
        public Zombies(int num) {
            this.num = num;
        protected void finalize() throws Throwable {
            System.out.println("Resurrect " + num);
        public String toString() {
            return "Zombies{" + "num=" + num + '}';
    public static void main(String... args) throws InterruptedException {
        for (int i = 0; i < 3; i++)
            ZOMBIES.add(new Zombies(i));
        for (int j = 0; j < 5; j++) {
            System.out.println("Zombies: " + ZOMBIES);
Zombies: [Zombies{num=0}, Zombies{num=1}, Zombies{num=2}]
Resurrect 2
Resurrect 1
Resurrect 0
Zombies: [Zombies{num=2}, Zombies{num=1}, Zombies{num=0}]
Zombies: []
Zombies: []
Zombies: []
In this example, the Zombies are added once to the collection and resurrected once by the finalize method. When they are collected a second time, they have been flagged as finalized and not queued again.


While it's a good idea to avoid using finalize(), it is a small comfort to know it will only be called once it the object is resurrected.


Using Containers? Read our Kubernetes Comparison eBook to learn the positives and negatives of Kubernetes, Mesos, Docker Swarm and EC2 Container Services.


Published at DZone with permission of Peter Lawrey, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.


Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}