Is there a "finalize" method for arrays in Java?

Question

Suppose in java, I want to do some operations when an array (e.g., int[] a = new int[3]) is garbage-collected. I know there is a finalize methods for Objects. But is there a "finalize" method for arrays?

Answer 1

finalizers in their entirety are obsolete.

The ReferenceQueue system replaces it and can do this.

But please be aware that garbage collection often never even happens. The VM will shut down before it ever runs out of memory. There is no guarantee that an array that is no longer reachable, is going to be removed in a few moments. It may take days. Or it really will only take a moment. You don't get guarantees.

Answer 2

If you can use java-9 and up, there is the cleaner API that you can use. You need to carefully read the documentation so that (and the apiNote) you do not step on an obvious mistake :

The cleaning action is invoked only after the associated object becomes phantom reachable, so it is important that the object implementing the cleaning action does not hold references to the object

Also you need to create a wrapper around your array, but otherwise it is pretty doable. Here is an example emulating that:

    public static void main(String[] args) {

        ArrayWrapper wrapper = new ArrayWrapper(new int[]{1,2,3});
        wrapper = null;
        gc();

        System.out.println("Done");

    }

    static void gc() {
        for(int i=0;i<3;++i){
            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
            System.gc();
        }
    }

    static class ArrayWrapper implements AutoCloseable {

        private static final Cleaner CLEANER = Cleaner.create();
        private final Inner inner;
        private final Cleaner.Cleanable cleanable;

        public ArrayWrapper(int[] array) {
            this.inner = new Inner(array);
            cleanable = CLEANER.register(this, inner);
        }

        public int[] getArray() {
            return inner.array;
        }

        @Override
        public void close() {
            System.out.println("close called");
            cleanable.clean();
        }

        static class Inner implements Runnable {

            private final int [] array;

            public Inner(int[] array) {
                this.array = array;
            }

            @Override
            public void run() {
                System.out.println("Run called");
            }
        }
    }

When running this, I get:

Run called
Done

which basically tells you that once wrapper is garbaged collected, it runs the action in Inner (that is a Runnable).

Notice that ArrayWrapper also implements AutoCloseable, so that you could use it in try with resource constructs, if your code allows it. That would be far simpler, too; if you wanted to achieve something like : "when wrapper goes out of scope, do some action in close method".