changeset 1189:164ce9ff8b58

6829503: addShutdownHook fails if called after shutdown has commenced. Summary: allow shutdown hook to be added during shutdown and handle properly if it fails to add Reviewed-by: alanb, dholmes, martin
author mchung
date Mon, 27 Apr 2009 12:08:41 -0700
parents 057e4afcf978
children d2114c1adb2d
files src/share/classes/java/io/Console.java src/share/classes/java/io/DeleteOnExitHook.java src/share/classes/java/lang/ApplicationShutdownHooks.java src/share/classes/java/lang/Shutdown.java src/share/classes/java/lang/System.java src/share/classes/sun/misc/JavaLangAccess.java test/java/lang/Runtime/shutdown/ShutdownHooks.java test/java/lang/Runtime/shutdown/ShutdownHooks.sh
diffstat 8 files changed, 237 insertions(+), 44 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/java/io/Console.java	Thu Apr 23 19:44:43 2009 +0100
+++ b/src/share/classes/java/io/Console.java	Mon Apr 27 12:08:41 2009 -0700
@@ -503,20 +503,25 @@
 
     // Set up JavaIOAccess in SharedSecrets
     static {
-
-        // Add a shutdown hook to restore console's echo state should
-        // it be necessary.
-        sun.misc.SharedSecrets.getJavaLangAccess()
-            .registerShutdownHook(0 /* shutdown hook invocation order */,
-                new Runnable() {
-                    public void run() {
-                        try {
-                            if (echoOff) {
-                                echo(true);
-                            }
-                        } catch (IOException x) { }
-                    }
-                });
+        try {
+            // Add a shutdown hook to restore console's echo state should
+            // it be necessary.
+            sun.misc.SharedSecrets.getJavaLangAccess()
+                .registerShutdownHook(0 /* shutdown hook invocation order */,
+                    false /* only register if shutdown is not in progress */,
+                    new Runnable() {
+                        public void run() {
+                            try {
+                                if (echoOff) {
+                                    echo(true);
+                                }
+                            } catch (IOException x) { }
+                        }
+                    });
+        } catch (IllegalStateException e) {
+            // shutdown is already in progress and console is first used
+            // by a shutdown hook
+        }
 
         sun.misc.SharedSecrets.setJavaIOAccess(new sun.misc.JavaIOAccess() {
             public Console console() {
--- a/src/share/classes/java/io/DeleteOnExitHook.java	Thu Apr 23 19:44:43 2009 +0100
+++ b/src/share/classes/java/io/DeleteOnExitHook.java	Mon Apr 27 12:08:41 2009 -0700
@@ -34,23 +34,31 @@
  */
 
 class DeleteOnExitHook {
+    private static LinkedHashSet<String> files = new LinkedHashSet<String>();
     static {
-         sun.misc.SharedSecrets.getJavaLangAccess()
-             .registerShutdownHook(2 /* Shutdown hook invocation order */,
-                 new Runnable() {
-                     public void run() {
-                        runHooks();
-                     }
-                 });
+        // DeleteOnExitHook must be the last shutdown hook to be invoked.
+        // Application shutdown hooks may add the first file to the
+        // delete on exit list and cause the DeleteOnExitHook to be
+        // registered during shutdown in progress. So set the
+        // registerShutdownInProgress parameter to true.
+        sun.misc.SharedSecrets.getJavaLangAccess()
+            .registerShutdownHook(2 /* Shutdown hook invocation order */,
+                true /* register even if shutdown in progress */,
+                new Runnable() {
+                    public void run() {
+                       runHooks();
+                    }
+                }
+        );
     }
 
-    private static LinkedHashSet<String> files = new LinkedHashSet<String>();
-
     private DeleteOnExitHook() {}
 
     static synchronized void add(String file) {
-        if(files == null)
+        if(files == null) {
+            // DeleteOnExitHook is running. Too late to add a file
             throw new IllegalStateException("Shutdown in progress");
+        }
 
         files.add(file);
     }
--- a/src/share/classes/java/lang/ApplicationShutdownHooks.java	Thu Apr 23 19:44:43 2009 +0100
+++ b/src/share/classes/java/lang/ApplicationShutdownHooks.java	Mon Apr 27 12:08:41 2009 -0700
@@ -35,17 +35,26 @@
  */
 
 class ApplicationShutdownHooks {
+    /* The set of registered hooks */
+    private static IdentityHashMap<Thread, Thread> hooks;
     static {
-        Shutdown.add(1 /* shutdown hook invocation order */,
-            new Runnable() {
-                public void run() {
-                    runHooks();
+        try {
+            Shutdown.add(1 /* shutdown hook invocation order */,
+                false /* not registered if shutdown in progress */,
+                new Runnable() {
+                    public void run() {
+                        runHooks();
+                    }
                 }
-            });
+            );
+            hooks = new IdentityHashMap<Thread, Thread>();
+        } catch (IllegalStateException e) {
+            // application shutdown hooks cannot be added if
+            // shutdown is in progress.
+            hooks = null;
+        }
     }
 
-    /* The set of registered hooks */
-    private static IdentityHashMap<Thread, Thread> hooks = new IdentityHashMap<Thread, Thread>();
 
     private ApplicationShutdownHooks() {}
 
--- a/src/share/classes/java/lang/Shutdown.java	Thu Apr 23 19:44:43 2009 +0100
+++ b/src/share/classes/java/lang/Shutdown.java	Mon Apr 27 12:08:41 2009 -0700
@@ -53,6 +53,9 @@
     private static final int MAX_SYSTEM_HOOKS = 10;
     private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
 
+    // the index of the currently running shutdown hook to the hooks array
+    private static int currentRunningHook = 0;
+
     /* The preceding static fields are protected by this lock */
     private static class Lock { };
     private static Object lock = new Lock();
@@ -68,17 +71,39 @@
     }
 
 
-    /* Add a new shutdown hook.  Checks the shutdown state and the hook itself,
+    /**
+     * Add a new shutdown hook.  Checks the shutdown state and the hook itself,
      * but does not do any security checks.
+     *
+     * The registerShutdownInProgress parameter should be false except
+     * registering the DeleteOnExitHook since the first file may
+     * be added to the delete on exit list by the application shutdown
+     * hooks.
+     *
+     * @params slot  the slot in the shutdown hook array, whose element
+     *               will be invoked in order during shutdown
+     * @params registerShutdownInProgress true to allow the hook
+     *               to be registered even if the shutdown is in progress.
+     * @params hook  the hook to be registered
+     *
+     * @throw IllegalStateException
+     *        if registerShutdownInProgress is false and shutdown is in progress; or
+     *        if registerShutdownInProgress is true and the shutdown process
+     *           already passes the given slot
      */
-    static void add(int slot, Runnable hook) {
+    static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
         synchronized (lock) {
-            if (state > RUNNING)
-                throw new IllegalStateException("Shutdown in progress");
-
             if (hooks[slot] != null)
                 throw new InternalError("Shutdown hook at slot " + slot + " already registered");
 
+            if (!registerShutdownInProgress) {
+                if (state > RUNNING)
+                    throw new IllegalStateException("Shutdown in progress");
+            } else {
+                if (state > HOOKS || (state == HOOKS && slot <= currentRunningHook))
+                    throw new IllegalStateException("Shutdown in progress");
+            }
+
             hooks[slot] = hook;
         }
     }
@@ -86,11 +111,15 @@
     /* Run all registered shutdown hooks
      */
     private static void runHooks() {
-        /* We needn't bother acquiring the lock just to read the hooks field,
-         * since the hooks can't be modified once shutdown is in progress
-         */
-        for (Runnable hook : hooks) {
+        for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
             try {
+                Runnable hook;
+                synchronized (lock) {
+                    // acquire the lock to make sure the hook registered during
+                    // shutdown is visible here.
+                    currentRunningHook = i;
+                    hook = hooks[i];
+                }
                 if (hook != null) hook.run();
             } catch(Throwable t) {
                 if (t instanceof ThreadDeath) {
--- a/src/share/classes/java/lang/System.java	Thu Apr 23 19:44:43 2009 +0100
+++ b/src/share/classes/java/lang/System.java	Mon Apr 27 12:08:41 2009 -0700
@@ -1171,8 +1171,8 @@
             public void blockedOn(Thread t, Interruptible b) {
                 t.blockedOn(b);
             }
-            public void registerShutdownHook(int slot, Runnable r) {
-                Shutdown.add(slot, r);
+            public void registerShutdownHook(int slot, boolean registerShutdownInProgress, Runnable hook) {
+                Shutdown.add(slot, registerShutdownInProgress, hook);
             }
         });
     }
--- a/src/share/classes/sun/misc/JavaLangAccess.java	Thu Apr 23 19:44:43 2009 +0100
+++ b/src/share/classes/sun/misc/JavaLangAccess.java	Mon Apr 27 12:08:41 2009 -0700
@@ -55,6 +55,22 @@
     /** Set thread's blocker field. */
     void blockedOn(Thread t, Interruptible b);
 
-    /** register shutdown hook */
-    void registerShutdownHook(int slot, Runnable r);
+    /**
+     * Registers a shutdown hook.
+     *
+     * It is expected that this method with registerShutdownInProgress=true
+     * is only used to register DeleteOnExitHook since the first file
+     * may be added to the delete on exit list by the application shutdown
+     * hooks.
+     *
+     * @params slot  the slot in the shutdown hook array, whose element
+     *               will be invoked in order during shutdown
+     * @params registerShutdownInProgress true to allow the hook
+     *               to be registered even if the shutdown is in progress.
+     * @params hook  the hook to be registered
+     *
+     * @throw IllegalStateException if shutdown is in progress and
+     *          the slot is not valid to register.
+     */
+    void registerShutdownHook(int slot, boolean registerShutdownInProgress, Runnable hook);
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/Runtime/shutdown/ShutdownHooks.java	Mon Apr 27 12:08:41 2009 -0700
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * @bug      6829503
+ * @summary  1) Test Console and DeleteOnExitHook can be initialized
+ *              while shutdown is in progress
+ *           2) Test if files that are added by the application shutdown
+ *              hook are deleted on exit during shutdown
+ */
+import java.io.*;
+public class ShutdownHooks {
+    private static File file;
+    public static void main(String[] args) throws Exception {
+        if (args.length != 2) {
+            throw new IllegalArgumentException("Usage: ShutdownHooks <dir> <filename>");
+        }
+
+        // Add a shutdown hook
+        Runtime.getRuntime().addShutdownHook(new Cleaner());
+
+        File dir = new File(args[0]);
+        file = new File(dir, args[1]);
+        // write to file
+        System.out.println("writing to "+ file);
+        PrintWriter pw = new PrintWriter(file);
+        pw.println("Shutdown begins");
+        pw.close();
+    }
+
+    public static class Cleaner extends Thread {
+        public void run() {
+            // register the Console's shutdown hook while the application
+            // shutdown hook is running
+            Console cons = System.console();
+            // register the DeleteOnExitHook while the application
+            // shutdown hook is running
+            file.deleteOnExit();
+            try {
+                PrintWriter pw = new PrintWriter(file);
+                pw.println("file is being deleted");
+                pw.close();
+            } catch (FileNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/Runtime/shutdown/ShutdownHooks.sh	Mon Apr 27 12:08:41 2009 -0700
@@ -0,0 +1,57 @@
+#!/bin/sh
+
+#
+# Copyright 2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#
+
+
+# @test
+# @bug 6829503
+# @summary  1) Test Console and DeleteOnExitHook can be initialized
+#              while shutdown is in progress
+#           2) Test if files that are added by the application shutdown
+#              hook are deleted on exit during shutdown
+#
+# @build ShutdownHooks 
+# @run shell ShutdownHooks.sh
+
+if [ "${TESTJAVA}" = "" ]
+then
+  echo "TESTJAVA not set.  Test cannot execute.  Failed."
+  exit 1
+fi
+
+FILENAME=fileToBeDeleted
+rm -f ${TESTCLASSES}/${FILENAME}
+
+# create the file to be deleted on exit
+echo "testing shutdown" > ${TESTCLASSES}/${FILENAME}
+
+${TESTJAVA}/bin/java ${TESTVMOPTS} -classpath ${TESTCLASSES} ShutdownHooks ${TESTCLASSES} $FILENAME 
+if [ $? != 0 ] ; then
+  echo "Test Failed"; exit 1
+fi
+
+if [ -f ${TESTCLASSES}/${FILENAME} ]; then
+  echo "Test Failed: ${TESTCLASSES}/${FILENAME} not deleted"; exit 2
+fi
+echo "ShutdownHooks test passed.";