< prev index next >
src/java.base/share/classes/java/lang/Runtime.java
Print this page
@@ -33,10 +33,12 @@
import java.util.stream.Collectors;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.StringTokenizer;
+
+import jdk.internal.misc.SharedSecrets;
import jdk.internal.reflect.CallerSensitive;
import jdk.internal.reflect.Reflection;
/**
* Every Java application has a single instance of class
@@ -75,23 +77,21 @@
* Terminates the currently running Java virtual machine by initiating its
* shutdown sequence. This method never returns normally. The argument
* serves as a status code; by convention, a nonzero status code indicates
* abnormal termination.
*
- * <p> The virtual machine's shutdown sequence consists of two phases. In
- * the first phase all registered {@link #addShutdownHook shutdown hooks},
- * if any, are started in some unspecified order and allowed to run
- * concurrently until they finish. In the second phase all uninvoked
- * finalizers are run if {@link #runFinalizersOnExit finalization-on-exit}
- * has been enabled. Once this is done the virtual machine {@link #halt halts}.
- *
- * <p> If this method is invoked after the virtual machine has begun its
- * shutdown sequence then if shutdown hooks are being run this method will
- * block indefinitely. If shutdown hooks have already been run and on-exit
- * finalization has been enabled then this method halts the virtual machine
- * with the given status code if the status is nonzero; otherwise, it
- * blocks indefinitely.
+ * <p> All registered {@link #addShutdownHook shutdown hooks}, if any,
+ * are started in some unspecified order and allowed to run concurrently
+ * until they finish. Once this is done the virtual machine
+ * {@link #halt halts}.
+ *
+ * <p> If this method is invoked after the virtual machine has started
+ * shutdown hooks then if shutdown hooks have already been run and
+ * the status is nonzero then this method halts the virtual machine
+ * with the given status code; otherwise, this method blocks indefinitely
+ * (i.e. if shutdown hooks are being run or if shutdown hooks have already
+ * been run and the status is zero).
*
* <p> The {@link System#exit(int) System.exit} method is the
* conventional and convenient means of invoking this method.
*
* @param status
@@ -105,11 +105,10 @@
*
* @see java.lang.SecurityException
* @see java.lang.SecurityManager#checkExit(int)
* @see #addShutdownHook
* @see #removeShutdownHook
- * @see #runFinalizersOnExit
* @see #halt(int)
*/
public void exit(int status) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
@@ -138,14 +137,13 @@
*
* <p> A <i>shutdown hook</i> is simply an initialized but unstarted
* thread. When the virtual machine begins its shutdown sequence it will
* start all registered shutdown hooks in some unspecified order and let
* them run concurrently. When all the hooks have finished it will then
- * run all uninvoked finalizers if finalization-on-exit has been enabled.
- * Finally, the virtual machine will halt. Note that daemon threads will
- * continue to run during the shutdown sequence, as will non-daemon threads
- * if shutdown was initiated by invoking the {@link #exit exit} method.
+ * halt. Note that daemon threads will continue to run during the shutdown
+ * sequence, as will non-daemon threads if shutdown was initiated by
+ * invoking the {@link #exit exit} method.
*
* <p> Once the shutdown sequence has begun it can be stopped only by
* invoking the {@link #halt halt} method, which forcibly
* terminates the virtual machine.
*
@@ -251,14 +249,13 @@
* Forcibly terminates the currently running Java virtual machine. This
* method never returns normally.
*
* <p> This method should be used with extreme caution. Unlike the
* {@link #exit exit} method, this method does not cause shutdown
- * hooks to be started and does not run uninvoked finalizers if
- * finalization-on-exit has been enabled. If the shutdown sequence has
- * already been initiated then this method does not wait for any running
- * shutdown hooks or finalizers to finish their work.
+ * hooks to be started. If the shutdown sequence has already been
+ * initiated then this method does not wait for any running
+ * shutdown hooks to finish their work.
*
* @param status
* Termination status. By convention, a nonzero status code
* indicates abnormal termination. If the {@link Runtime#exit exit}
* (equivalently, {@link System#exit(int) System.exit}) method
@@ -282,50 +279,10 @@
}
Shutdown.halt(status);
}
/**
- * Enable or disable finalization on exit; doing so specifies that the
- * finalizers of all objects that have finalizers that have not yet been
- * automatically invoked are to be run before the Java runtime exits.
- * By default, finalization on exit is disabled.
- *
- * <p>If there is a security manager,
- * its {@code checkExit} method is first called
- * with 0 as its argument to ensure the exit is allowed.
- * This could result in a SecurityException.
- *
- * @param value true to enable finalization on exit, false to disable
- * @deprecated This method is inherently unsafe. It may result in
- * finalizers being called on live objects while other threads are
- * concurrently manipulating those objects, resulting in erratic
- * behavior or deadlock.
- * This method is subject to removal in a future version of Java SE.
- *
- * @throws SecurityException
- * if a security manager exists and its {@code checkExit}
- * method doesn't allow the exit.
- *
- * @see java.lang.Runtime#exit(int)
- * @see java.lang.Runtime#gc()
- * @see java.lang.SecurityManager#checkExit(int)
- * @since 1.1
- */
- @Deprecated(since="1.2", forRemoval=true)
- public static void runFinalizersOnExit(boolean value) {
- SecurityManager security = System.getSecurityManager();
- if (security != null) {
- try {
- security.checkExit(0);
- } catch (SecurityException e) {
- throw new SecurityException("runFinalizersOnExit");
- }
- }
- Shutdown.setRunFinalizersOnExit(value);
- }
-
- /**
* Executes the specified string command in a separate process.
*
* <p>This is a convenience method. An invocation of the form
* {@code exec(command)}
* behaves in exactly the same way as the invocation
@@ -700,13 +657,10 @@
* The method {@link System#gc()} is the conventional and convenient
* means of invoking this method.
*/
public native void gc();
- /* Wormhole for calling java.lang.ref.Finalizer.runFinalization */
- private static native void runFinalization0();
-
/**
* Runs the finalization methods of any objects pending finalization.
* Calling this method suggests that the Java virtual machine expend
* effort toward running the {@code finalize} methods of objects
* that have been found to be discarded but whose {@code finalize}
@@ -722,11 +676,11 @@
* and convenient means of invoking this method.
*
* @see java.lang.Object#finalize()
*/
public void runFinalization() {
- runFinalization0();
+ SharedSecrets.getJavaLangRefAccess().runFinalization();
}
/**
* Not implemented, does nothing.
*
< prev index next >