| Methods Summary |
|---|
| public void | addShutdownHook(java.lang.Thread hook)Registers a virtual-machine shutdown hook. A shutdown hook is a
{@code Thread} that is ready to run, but has not yet been started. All
registered shutdown hooks will be executed once the virtual machine shuts
down properly. A proper shutdown happens when either the
{@link #exit(int)} method is called or the surrounding system decides to
terminate the application, for example in response to a {@code CTRL-C} or
a system-wide shutdown. A termination of the virtual machine due to the
{@link #halt(int)} method, an {@link Error} or a {@code SIGKILL}, in
contrast, is not considered a proper shutdown. In these cases the
shutdown hooks will not be run.
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 {@code halt()}.
If {@link #runFinalizersOnExit(boolean)} has been called with a {@code
true} argument, garbage collection and finalization will take place after
all hooks are either finished or have failed. Then the virtual machine
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.
// Sanity checks
if (hook == null) {
throw new NullPointerException("Hook may not be null.");
}
if (shuttingDown) {
throw new IllegalStateException("VM already shutting down");
}
if (hook.hasBeenStarted) {
throw new IllegalArgumentException("Hook has already been started");
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("shutdownHooks"));
}
synchronized (shutdownHooks) {
if (shutdownHooks.contains(hook)) {
throw new IllegalArgumentException("Hook already registered.");
}
shutdownHooks.add(hook);
}
|
| public int | availableProcessors()Returns the number of processors available to the virtual machine. The
Android reference implementation (currently) always returns 1.
return 1;
|
| public java.lang.Process | exec(java.lang.String[] progArray)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 {@code exec(progArray, null, null)}.
return exec(progArray, null, null);
|
| public java.lang.Process | exec(java.lang.String[] progArray, java.lang.String[] envp)Executes the specified command and its arguments in a separate native
process. The new process uses the environment provided in {@code envp}.
Calling this method is equivalent to calling
{@code exec(progArray, envp, null)}.
return exec(progArray, envp, null);
|
| public java.lang.Process | exec(java.lang.String[] progArray, java.lang.String[] envp, java.io.File directory)Executes the specified command and its arguments in a separate native
process. The new process uses the environment provided in {@code envp}
and the working directory specified by {@code directory}.
// Sanity checks
if (progArray == null) {
throw new NullPointerException();
} else if (progArray.length == 0) {
throw new IndexOutOfBoundsException();
} else {
for (int i = 0; i < progArray.length; i++) {
if (progArray[i] == null) {
throw new NullPointerException();
}
}
}
if (envp != null) {
for (int i = 0; i < envp.length; i++) {
if (envp[i] == null) {
throw new NullPointerException();
}
}
}
// Security checks
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
smgr.checkExec(progArray[0]);
}
// Delegate the execution
return ProcessManager.getInstance().exec(progArray, envp, directory);
|
| public java.lang.Process | exec(java.lang.String prog)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 {@code exec(prog, null, null)}.
return exec(prog, null, null);
|
| public java.lang.Process | exec(java.lang.String prog, java.lang.String[] envp)Executes the specified program in a separate native process. The new
process uses the environment provided in {@code envp}. Calling this
method is equivalent to calling {@code exec(prog, envp, null)}.
return exec(prog, envp, null);
|
| public java.lang.Process | exec(java.lang.String prog, java.lang.String[] envp, java.io.File directory)Executes the specified program in a separate native process. The new
process uses the environment provided in {@code envp} and the working
directory specified by {@code directory}.
// Sanity checks
if (prog == null) {
throw new NullPointerException();
} else if (prog.length() == 0) {
throw new IllegalArgumentException();
}
// Break down into tokens, as described in Java docs
StringTokenizer tokenizer = new StringTokenizer(prog);
int length = tokenizer.countTokens();
String[] progArray = new String[length];
for (int i = 0; i < length; i++) {
progArray[i] = tokenizer.nextToken();
}
// Delegate
return exec(progArray, envp, directory);
|
| public void | exit(int code)Causes the virtual machine to stop running and the program to exit. If
{@link #runFinalizersOnExit(boolean)} has been previously invoked with a
{@code true} argument, then all all objects will be properly
garbage-collected and finalized first.
// Security checks
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
smgr.checkExit(code);
}
// Make sure we don't try this several times
synchronized(this) {
if (!shuttingDown) {
shuttingDown = true;
Thread[] hooks;
synchronized (shutdownHooks) {
// create a copy of the hooks
hooks = new Thread[shutdownHooks.size()];
shutdownHooks.toArray(hooks);
}
// Start all shutdown hooks concurrently
for (int i = 0; i < hooks.length; i++) {
hooks[i].start();
}
// Wait for all shutdown hooks to finish
for (Thread hook : hooks) {
try {
hook.join();
} catch (InterruptedException ex) {
// Ignore, since we are at VM shutdown.
}
}
// Ensure finalization on exit, if requested
if (finalizeOnExit) {
runFinalization(true);
}
// Get out of here finally...
nativeExit(code, true);
}
}
|
| public native long | freeMemory()Returns the amount of free memory resources which are available to the
running program.
|
| public native void | gc()Indicates to the virtual machine 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.
|
| public java.io.InputStream | getLocalizedInputStream(java.io.InputStream stream)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.
if (System.getProperty("file.encoding", "UTF-8").equals("UTF-8")) {
return stream;
}
return new ReaderInputStream(stream);
|
| public java.io.OutputStream | getLocalizedOutputStream(java.io.OutputStream stream)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.
if (System.getProperty("file.encoding", "UTF-8").equals("UTF-8")) {
return stream;
}
return new WriterOutputStream(stream );
|
| public static java.lang.Runtime | getRuntime()Returns the single {@code Runtime} instance.
return mRuntime;
|
| public void | halt(int code)Causes the virtual machine to stop running, and the program to exit.
Neither shutdown hooks nor finalizers are run before.
// Security checks
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
smgr.checkExit(code);
}
// Get out of here...
nativeExit(code, false);
|
| public void | load(java.lang.String pathName)Loads and links the dynamic library that is identified through the
specified path. This method is similar to {@link #loadLibrary(String)},
but it accepts a full path specification whereas {@code loadLibrary} just
accepts the name of the library to load.
// Security checks
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
smgr.checkLink(pathName);
}
load(pathName, VMStack.getCallingClassLoader());
|
| void | load(java.lang.String filename, java.lang.ClassLoader loader)
if (filename == null) {
throw new NullPointerException("library path was null.");
}
if (!nativeLoad(filename, loader)) {
throw new UnsatisfiedLinkError(
"Library " + filename + " not found");
}
|
| public void | loadLibrary(java.lang.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.
// Security checks
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
smgr.checkLink(libName);
}
loadLibrary(libName, VMStack.getCallingClassLoader());
|
| void | loadLibrary(java.lang.String libname, java.lang.ClassLoader loader)
String filename;
int i;
if (loader != null) {
filename = loader.findLibrary(libname);
if (filename != null && nativeLoad(filename, loader))
return;
// else fall through to exception
} else {
filename = System.mapLibraryName(libname);
for (i = 0; i < mLibPaths.length; i++) {
if (false)
System.out.println("Trying " + mLibPaths[i] + filename);
if (nativeLoad(mLibPaths[i] + filename, loader))
return;
}
}
throw new UnsatisfiedLinkError("Library " + libname + " not found");
|
| public native long | maxMemory()Returns the maximum amount of memory that may be used by the virtual
machine, or {@code Long.MAX_VALUE} if there is no such limit.
|
| private static native void | nativeExit(int code, boolean isExit)
|
| private static native boolean | nativeLoad(java.lang.String filename, java.lang.ClassLoader loader)
|
| public boolean | removeShutdownHook(java.lang.Thread hook)Unregisters a previously registered virtual machine shutdown hook.
// Sanity checks
if (hook == null) {
throw new NullPointerException("Hook may not be null.");
}
if (shuttingDown) {
throw new IllegalStateException("VM already shutting down");
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("shutdownHooks"));
}
synchronized (shutdownHooks) {
return shutdownHooks.remove(hook);
}
|
| private native void | runFinalization(boolean forced)Requests proper finalization for all Objects on the heap.
|
| public void | runFinalization()Provides a hint to the virtual machine that it would be useful to attempt
to perform any outstanding object finalizations.
runFinalization(false);
|
| public static void | runFinalizersOnExit(boolean run)Sets the flag that indicates whether all objects are finalized when the
virtual machine is about to exit. Note that all finalization which occurs
when the system is exiting is performed after all running threads have
been terminated.
SecurityManager smgr = System.getSecurityManager();
if (smgr != null) {
smgr.checkExit(0);
}
finalizeOnExit = run;
|
| public native long | totalMemory()Returns the total amount of memory which is available to the running
program.
|
| public void | traceInstructions(boolean enable)Switches the output of debug information for instructions on or off.
For the Android 1.0 reference implementation, this method does nothing.
// TODO(Google) Provide some implementation for this.
return;
|
| public void | traceMethodCalls(boolean enable)Switches the output of debug information for methods on or off.
if (enable != tracingMethods) {
if (enable) {
VMDebug.startMethodTracing();
} else {
VMDebug.stopMethodTracing();
}
tracingMethods = enable;
}
|
