src/java.base/share/classes/java/lang/Shutdown.java

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 1999, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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.  Oracle designates this

@@ -37,16 +37,13 @@
 class Shutdown {
 
     /* Shutdown state */
     private static final int RUNNING = 0;
     private static final int HOOKS = 1;
-    private static final int FINALIZERS = 2;
+    private static final int COMPLETED = 2;
     private static int state = RUNNING;
 
-    /* Should we run all finalizers upon exit? */
-    private static boolean runFinalizersOnExit = false;
-
     // The system shutdown hooks are registered with a predefined slot.
     // The list of shutdown hooks is as follows:
     // (0) Console restore hook
     // (1) Application hooks
     // (2) DeleteOnExit hook

@@ -61,18 +58,10 @@
     private static Object lock = new Lock();
 
     /* Lock object for the native halt method */
     private static Object haltLock = new Lock();
 
-    /* Invoked by Runtime.runFinalizersOnExit */
-    static void setRunFinalizersOnExit(boolean run) {
-        synchronized (lock) {
-            runFinalizersOnExit = run;
-        }
-    }
-
-
     /**
      * 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

@@ -109,10 +98,17 @@
     }
 
     /* Run all registered shutdown hooks
      */
     private static void runHooks() {
+        synchronized (lock) {
+            /* Guard against the possibility of a daemon thread invoking exit
+             * after DestroyJavaVM initiates the shutdown sequence
+             */
+            if (state != HOOKS) return;
+        }
+
         for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
             try {
                 Runnable hook;
                 synchronized (lock) {
                     // acquire the lock to make sure the hook registered during

@@ -126,10 +122,14 @@
                     ThreadDeath td = (ThreadDeath)t;
                     throw td;
                 }
             }
         }
+
+        synchronized (lock) {
+            state = COMPLETED;
+        }
     }
 
     /* The halt method is synchronized on the halt lock
      * to avoid corruption of the delete-on-shutdown file list.
      * It invokes the true native halt method.

@@ -140,78 +140,35 @@
         }
     }
 
     static native void halt0(int status);
 
-    /* Wormhole for invoking java.lang.ref.Finalizer.runAllFinalizers */
-    private static native void runAllFinalizers();
-
-
-    /* The actual shutdown sequence is defined here.
-     *
-     * If it weren't for runFinalizersOnExit, this would be simple -- we'd just
-     * run the hooks and then halt.  Instead we need to keep track of whether
-     * we're running hooks or finalizers.  In the latter case a finalizer could
-     * invoke exit(1) to cause immediate termination, while in the former case
-     * any further invocations of exit(n), for any n, simply stall.  Note that
-     * if on-exit finalizers are enabled they're run iff the shutdown is
-     * initiated by an exit(0); they're never run on exit(n) for n != 0 or in
-     * response to SIGINT, SIGTERM, etc.
-     */
-    private static void sequence() {
-        synchronized (lock) {
-            /* Guard against the possibility of a daemon thread invoking exit
-             * after DestroyJavaVM initiates the shutdown sequence
-             */
-            if (state != HOOKS) return;
-        }
-        runHooks();
-        boolean rfoe;
-        synchronized (lock) {
-            state = FINALIZERS;
-            rfoe = runFinalizersOnExit;
-        }
-        if (rfoe) runAllFinalizers();
-    }
-
-
     /* Invoked by Runtime.exit, which does all the security checks.
      * Also invoked by handlers for system-provided termination events,
      * which should pass a nonzero status code.
      */
     static void exit(int status) {
-        boolean runMoreFinalizers = false;
         synchronized (lock) {
-            if (status != 0) runFinalizersOnExit = false;
             switch (state) {
             case RUNNING:       /* Initiate shutdown */
                 state = HOOKS;
                 break;
             case HOOKS:         /* Stall and halt */
                 break;
-            case FINALIZERS:
+            case COMPLETED:
                 if (status != 0) {
                     /* Halt immediately on nonzero status */
                     halt(status);
-                } else {
-                    /* Compatibility with old behavior:
-                     * Run more finalizers and then halt
-                     */
-                    runMoreFinalizers = runFinalizersOnExit;
                 }
                 break;
             }
         }
-        if (runMoreFinalizers) {
-            runAllFinalizers();
-            halt(status);
-        }
         synchronized (Shutdown.class) {
             /* Synchronize on the class object, causing any other thread
              * that attempts to initiate shutdown to stall indefinitely
              */
-            sequence();
+            runHooks();
             halt(status);
         }
     }
 
 

@@ -224,15 +181,16 @@
             switch (state) {
             case RUNNING:       /* Initiate shutdown */
                 state = HOOKS;
                 break;
             case HOOKS:         /* Stall and then return */
-            case FINALIZERS:
                 break;
+            case COMPLETED:
+                return;
             }
         }
         synchronized (Shutdown.class) {
-            sequence();
+            runHooks();
         }
     }
 
 }