--- old/src/java.base/share/classes/java/lang/Shutdown.java	2018-02-15 14:56:26.000000000 -0800
+++ new/src/java.base/share/classes/java/lang/Shutdown.java	2018-02-15 14:56:26.000000000 -0800
@@ -1,5 +1,5 @@
 /*
- * 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
@@ -39,12 +39,9 @@
     /* 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
@@ -63,14 +60,6 @@
     /* 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.
@@ -111,6 +100,13 @@
     /* 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;
@@ -128,6 +124,10 @@
                 }
             }
         }
+
+        synchronized (lock) {
+            state = COMPLETED;
+        }
     }
 
     /* The halt method is synchronized on the halt lock
@@ -142,74 +142,31 @@
 
     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);
         }
     }
@@ -226,12 +183,13 @@
                 state = HOOKS;
                 break;
             case HOOKS:         /* Stall and then return */
-            case FINALIZERS:
                 break;
+            case COMPLETED:
+                return;
             }
         }
         synchronized (Shutdown.class) {
-            sequence();
+            runHooks();
         }
     }