Package java.lang

Class Runtime

java.lang.Object
java.lang.Runtime
public class Runtime
extends Object
Allows Java applications to interface with the environment in which they are running. Applications can not create an instance of this class, but they can get a singleton instance by invoking getRuntime().
See Also:
System

  • Method Details

    • exec

      public Process exec​(String[] progArray) throws IOException
      Executes the specified command and its arguments in a separate native process. The new process inherits the environment of the caller. Calling this method is equivalent to calling exec(progArray, null, null).
      Parameters:
      progArray - the array containing the program to execute as well as any arguments to the program.
      Returns:
      the new Process object that represents the native process.
      Throws:
      IOException - if the requested program can not be executed.

    • exec

      public Process exec​(String[] progArray, String[] envp) throws IOException
      Executes the specified command and its arguments in a separate native process. The new process uses the environment provided in envp. Calling this method is equivalent to calling exec(progArray, envp, null).
      Parameters:
      progArray - the array containing the program to execute as well as any arguments to the program.
      envp - the array containing the environment to start the new process in.
      Returns:
      the new Process object that represents the native process.
      Throws:
      IOException - if the requested program can not be executed.

    • exec

      public Process exec​(String[] progArray, String[] envp, File directory) throws IOException
      Executes the specified command and its arguments in a separate native process. The new process uses the environment provided in envp and the working directory specified by directory.
      Parameters:
      progArray - the array containing the program to execute as well as any arguments to the program.
      envp - the array containing the environment to start the new process in.
      directory - the directory in which to execute the program. If null, execute if in the same directory as the parent process.
      Returns:
      the new Process object that represents the native process.
      Throws:
      IOException - if the requested program can not be executed.

    • exec

      public Process exec​(String prog) throws IOException
      Executes the specified program in a separate native process. The new process inherits the environment of the caller. Calling this method is equivalent to calling exec(prog, null, null).
      Parameters:
      prog - the name of the program to execute.
      Returns:
      the new Process object that represents the native process.
      Throws:
      IOException - if the requested program can not be executed.

    • exec

      public Process exec​(String prog, String[] envp) throws IOException
      Executes the specified program in a separate native process. The new process uses the environment provided in envp. Calling this method is equivalent to calling exec(prog, envp, null).
      Parameters:
      prog - the name of the program to execute.
      envp - the array containing the environment to start the new process in.
      Returns:
      the new Process object that represents the native process.
      Throws:
      IOException - if the requested program can not be executed.

    • exec

      public Process exec​(String prog, String[] envp, File directory) throws IOException
      Executes the specified program in a separate native process. The new process uses the environment provided in envp and the working directory specified by directory.
      Parameters:
      prog - the name of the program to execute.
      envp - the array containing the environment to start the new process in.
      directory - the directory in which to execute the program. If null, execute if in the same directory as the parent process.
      Returns:
      the new Process object that represents the native process.
      Throws:
      IOException - if the requested program can not be executed.

    • exit

      public void exit​(int code)
      Causes the VM to stop running and the program to exit. If runFinalizersOnExit(boolean) has been previously invoked with a true argument, then all objects will be properly garbage-collected and finalized first. Use 0 to signal success to the calling process and 1 to signal failure. This method is unlikely to be useful to an Android application.

    • gc

      public void gc()
      Indicates to the VM that it would be a good time to run the garbage collector. Note that this is a hint only. There is no guarantee that the garbage collector will actually be run.

    • getRuntime

      public static Runtime getRuntime()
      Returns the single Runtime instance for the current application.

    • load

      public void load​(String pathName)
      Loads and links the dynamic library that is identified through the specified path. This method is similar to loadLibrary(String), but it accepts a full path specification whereas loadLibrary just accepts the name of the library to load.
      Parameters:
      pathName - the absolute (platform dependent) path to the library to load.
      Throws:
      UnsatisfiedLinkError - if the library can not be loaded.

    • loadLibrary

      public void loadLibrary​(String libName)
      Loads and links the library with the specified name. The mapping of the specified library name to the full path for loading the library is implementation-dependent.
      Parameters:
      libName - the name of the library to load.
      Throws:
      UnsatisfiedLinkError - if the library can not be loaded.

    • runFinalization

      public void runFinalization()
      Provides a hint to the VM that it would be useful to attempt to perform any outstanding object finalization.

    • runFinalizersOnExit

      @Deprecated public static void runFinalizersOnExit​(boolean run)
      Deprecated.
      This method is unsafe.
      Sets the flag that indicates whether all objects are finalized when the VM is about to exit. Note that all finalization which occurs when the system is exiting is performed after all running threads have been terminated.
      Parameters:
      run - true to enable finalization on exit, false to disable it.

    • traceInstructions

      public void traceInstructions​(boolean enable)
      Switches the output of debug information for instructions on or off. On Android, this method does nothing.

    • traceMethodCalls

      public void traceMethodCalls​(boolean enable)
      Switches the output of debug information for methods on or off.

    • getLocalizedInputStream

      @Deprecated public InputStream getLocalizedInputStream​(InputStream stream)
      Deprecated.
      Use InputStreamReader instead.
      Returns the localized version of the specified input stream. The input stream that is returned automatically converts all characters from the local character set to Unicode after reading them from the underlying stream.
      Parameters:
      stream - the input stream to localize.
      Returns:
      the localized input stream.

    • getLocalizedOutputStream

      @Deprecated public OutputStream getLocalizedOutputStream​(OutputStream stream)
      Deprecated.
      Use OutputStreamWriter instead.
      Returns the localized version of the specified output stream. The output stream that is returned automatically converts all characters from Unicode to the local character set before writing them to the underlying stream.
      Parameters:
      stream - the output stream to localize.
      Returns:
      the localized output stream.

    • addShutdownHook

      public void addShutdownHook​(Thread hook)
      Registers a VM shutdown hook. A shutdown hook is a Thread that is ready to run, but has not yet been started. All registered shutdown hooks will be executed when the VM terminates normally (typically when the exit(int) method is called).

      Note that on Android, the application lifecycle does not include VM termination, so calling this method will not ensure that your code is run. Instead, you should use the most appropriate lifecycle notification (Activity.onPause, say).

      Shutdown hooks are run concurrently and in an unspecified order. Hooks failing due to an unhandled exception are not a problem, but the stack trace might be printed to the console. Once initiated, the whole shutdown process can only be terminated by calling halt().

      If runFinalizersOnExit(boolean) has been called with a true argument, garbage collection and finalization will take place after all hooks are either finished or have failed. Then the VM terminates.

      It is recommended that shutdown hooks do not do any time-consuming activities, in order to not hold up the shutdown process longer than necessary.

      Parameters:
      hook - the shutdown hook to register.
      Throws:
      IllegalArgumentException - if the hook has already been started or if it has already been registered.
      IllegalStateException - if the VM is already shutting down.

    • removeShutdownHook

      public boolean removeShutdownHook​(Thread hook)
      Unregisters a previously registered VM shutdown hook.
      Parameters:
      hook - the shutdown hook to remove.
      Returns:
      true if the hook has been removed successfully; false otherwise.
      Throws:
      IllegalStateException - if the VM is already shutting down.

    • halt

      public void halt​(int code)
      Causes the VM to stop running, and the program to exit with the given return code. Use 0 to signal success to the calling process and 1 to signal failure. Neither shutdown hooks nor finalizers are run before exiting. This method is unlikely to be useful to an Android application.

    • availableProcessors

      public int availableProcessors()
      Returns the number of processor cores available to the VM, at least 1. Traditionally this returned the number currently online, but many mobile devices are able to take unused cores offline to save power, so releases newer than Android 4.2 (Jelly Bean) return the maximum number of cores that could be made available if there were no power or heat constraints.

    • freeMemory

      public long freeMemory()
      Returns the number of bytes currently available on the heap without expanding the heap. See totalMemory() for the heap's current size. When these bytes are exhausted, the heap may expand. See maxMemory() for that limit.

    • totalMemory

      public long totalMemory()
      Returns the number of bytes taken by the heap at its current size. The heap may expand or contract over time, as the number of live objects increases or decreases. See maxMemory() for the maximum heap size, and freeMemory() for an idea of how much the heap could currently contract.

    • maxMemory

      public long maxMemory()
      Returns the maximum number of bytes the heap can expand to. See totalMemory() for the current number of bytes taken by the heap, and freeMemory() for the current number of those bytes actually used by live objects.