/*

 * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package nsk.share;

import java.util.Stack;

/**

 * Finalizer performs object finalization when virtual mashine shuts down.

 * Finalizer is a thread that acts as a VM shutdown hook.

 * This thread will be activated as VM shuts down because of

 * invocation of <code>exit()</code> or termination. After activation

 * Finalizer just calls <code>finalizeAtExit()</code> method of the specified object.

 * The finalizable object should implement interface <code>Finalizable</code>.

 *

 * @see Finalizable

 */

public class Finalizer {

    /** Finalizer thread to register as a VM shutdown hook. */

    private static FinalizerThread finalizerThread = null;

    /** An object to finalize. */

    private Finalizable object;

    /**

     * Create finalizer for the specified object.

     */

    public Finalizer(Finalizable object) {

        this.object = object;

    }

    /**

     * Register finalizer for finalization at VM shutdown.

     */

    public void activate() {

        if (finalizerThread == null) {

            finalizerThread = new FinalizerThread("FinalizerThread for Finalizable objects");

            finalizerThread.activate();

        }

        finalizerThread.add(object);

    }

    /**

     * Unregister finalizer for finalization at VM shutdown.

     */

    public void deactivate() {

        if (finalizerThread == null)

            return;

        finalizerThread.remove(object);

    }

    /**

     * Static inner thread that is registered as a VM shutdown hook

     * and performs finalization of all registered finalizable objects.

     */

    private static class FinalizerThread extends Thread {

        /** Stack of objects registered for finalization. */

        private Stack<Object> objects = new Stack<Object>();

        /** Make new instance of FinalizerThread with given thread name. */

        public FinalizerThread(String threadName) {

            super(threadName);

        }

        /**

         * Push an object to the stack of registered objects.

         */

        public void add(Finalizable object) {

            objects.push(object);

        }

        /**

         * Remove an object from the stack of registered objects.

         */

        public void remove(Finalizable object) {

            objects.remove(object);

        }

        /**

         * Register finalizer thread as a VM shutdown hook.

         */

        public void activate() {

            Runtime.getRuntime().addShutdownHook( this );

        }

        /**

         * Unregister finalizer thread as a VM shutdown hook.

         */

        public void deactivate() {

            Runtime.getRuntime().removeShutdownHook( this );

        }

        /**

         * Pop all registered objects from the stack and finalize them.

         */

        public void run() {

            while (!objects.empty()) {

                Finalizable object = (Finalizable)objects.pop();

                try {

                    object.finalizeAtExit();

                } catch (ThreadDeath e) {

                    throw e;

                } catch (Throwable ex) {

                    ex.printStackTrace();

                }

            }

        }

    } // end of FinalizerThread

} // end of Finalizer