- Android java runtime class
- Method Summary
- Methods inherited from class java.lang.Object
- Method Detail
- getRuntime
- addShutdownHook
- removeShutdownHook
- runFinalizersOnExit
- availableProcessors
- freeMemory
- totalMemory
- maxMemory
- runFinalization
- traceInstructions
- traceMethodCalls
- loadLibrary
- getLocalizedInputStream
- getLocalizedOutputStream
- Jake Wharton
- Android’s Java 9, 10, 11, and 12 Support
- Java 9
- Concise Try With Resources
- Anonymous Diamond
- Private Interface Methods
- String Concat
- Java 10
- Java 11
- Nestmates
- Java 12
Android java runtime class
An application cannot create its own instance of this class.
Method Summary
Modifier and Type | Method and Description |
---|---|
void | addShutdownHook (Thread hook) |
Methods inherited from class java.lang.Object
Method Detail
getRuntime
The virtual machine’s shutdown sequence consists of two phases. In the first phase all registered 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 finalization-on-exit has been enabled. Once this is done the virtual machine halts .
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.
The System.exit method is the conventional and convenient means of invoking this method.
addShutdownHook
The Java virtual machine shuts down in response to two kinds of events:
- The program exits normally, when the last non-daemon thread exits or when the exit (equivalently, System.exit ) method is invoked, or
- The virtual machine is terminated in response to a user interrupt, such as typing ^C, or a system-wide event, such as user logoff or system shutdown.
A shutdown hook 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 exit method.
Once the shutdown sequence has begun it can be stopped only by invoking the halt method, which forcibly terminates the virtual machine.
Once the shutdown sequence has begun it is impossible to register a new shutdown hook or de-register a previously-registered hook. Attempting either of these operations will cause an IllegalStateException to be thrown.
Shutdown hooks run at a delicate time in the life cycle of a virtual machine and should therefore be coded defensively. They should, in particular, be written to be thread-safe and to avoid deadlocks insofar as possible. They should also not rely blindly upon services that may have registered their own shutdown hooks and therefore may themselves in the process of shutting down. Attempts to use other thread-based services such as the AWT event-dispatch thread, for example, may lead to deadlocks.
Shutdown hooks should also finish their work quickly. When a program invokes exit the expectation is that the virtual machine will promptly shut down and exit. When the virtual machine is terminated due to user logoff or system shutdown the underlying operating system may only allow a fixed amount of time in which to shut down and exit. It is therefore inadvisable to attempt any user interaction or to perform a long-running computation in a shutdown hook.
Uncaught exceptions are handled in shutdown hooks just as in any other thread, by invoking the uncaughtException method of the thread’s ThreadGroup object. The default implementation of this method prints the exception’s stack trace to System.err and terminates the thread; it does not cause the virtual machine to exit or halt.
In rare circumstances the virtual machine may abort, that is, stop running without shutting down cleanly. This occurs when the virtual machine is terminated externally, for example with the SIGKILL signal on Unix or the TerminateProcess call on Microsoft Windows. The virtual machine may also abort if a native method goes awry by, for example, corrupting internal data structures or attempting to access nonexistent memory. If the virtual machine aborts then no guarantee can be made about whether or not any shutdown hooks will be run.
removeShutdownHook
This method should be used with extreme caution. Unlike the 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.
runFinalizersOnExit
If there is a security manager, its checkExit method is first called with 0 as its argument to ensure the exit is allowed. This could result in a SecurityException.
This is a convenience method. An invocation of the form exec(command) behaves in exactly the same way as the invocation exec (command, null, null).
This is a convenience method. An invocation of the form exec(command, envp) behaves in exactly the same way as the invocation exec (command, envp, null).
This is a convenience method. An invocation of the form exec(command, envp, dir) behaves in exactly the same way as the invocation exec (cmdarray, envp, dir), where cmdarray is an array of all the tokens in command .
More precisely, the command string is broken into tokens using a StringTokenizer created by the call new StringTokenizer (command) with no further modification of the character categories. The tokens produced by the tokenizer are then placed in the new string array cmdarray , in the same order.
This is a convenience method. An invocation of the form exec(cmdarray) behaves in exactly the same way as the invocation exec (cmdarray, null, null).
This is a convenience method. An invocation of the form exec(cmdarray, envp) behaves in exactly the same way as the invocation exec (cmdarray, envp, null).
Given an array of strings cmdarray , representing the tokens of a command line, and an array of strings envp , representing «environment» variable settings, this method creates a new process in which to execute the specified command.
This method checks that cmdarray is a valid operating system command. Which commands are valid is system-dependent, but at the very least the command must be a non-empty list of non-null strings.
If envp is null, the subprocess inherits the environment settings of the current process.
A minimal set of system dependent environment variables may be required to start a process on some operating systems. As a result, the subprocess may inherit additional environment variable settings beyond those in the specified environment.
ProcessBuilder.start() is now the preferred way to start a process with a modified environment.
The working directory of the new subprocess is specified by dir. If dir is null, the subprocess inherits the current working directory of the current process.
If a security manager exists, its checkExec method is invoked with the first component of the array cmdarray as its argument. This may result in a SecurityException being thrown.
Starting an operating system process is highly system-dependent. Among the many things that can go wrong are:
- The operating system program file was not found.
- Access to the program file was denied.
- The working directory does not exist.
In such cases an exception will be thrown. The exact nature of the exception is system-dependent, but it will always be a subclass of IOException .
availableProcessors
This value may change during a particular invocation of the virtual machine. Applications that are sensitive to the number of available processors should therefore occasionally poll this property and adjust their resource usage appropriately.
freeMemory
totalMemory
Note that the amount of memory required to hold an object of any given type may be implementation-dependent.
maxMemory
The name gc stands for «garbage collector». The virtual machine performs this recycling process automatically as needed, in a separate thread, even if the gc method is not invoked explicitly.
The method System.gc() is the conventional and convenient means of invoking this method.
runFinalization
The virtual machine performs the finalization process automatically as needed, in a separate thread, if the runFinalization method is not invoked explicitly.
The method System.runFinalization() is the conventional and convenient means of invoking this method.
traceInstructions
If the boolean argument is false , this method causes the virtual machine to stop performing the detailed instruction trace it is performing.
traceMethodCalls
Calling this method with argument false suggests that the virtual machine cease emitting per-call debugging information.
First, if there is a security manager, its checkLink method is called with the filename as its argument. This may result in a security exception.
This is similar to the method loadLibrary(String) , but it accepts a general file name as an argument rather than just a library name, allowing any file of native code to be loaded.
The method System.load(String) is the conventional and convenient means of invoking this method.
loadLibrary
First, if there is a security manager, its checkLink method is called with the libname as its argument. This may result in a security exception.
The method System.loadLibrary(String) is the conventional and convenient means of invoking this method. If native methods are to be used in the implementation of a class, a standard strategy is to put the native code in a library file (call it LibFile ) and then to put a static initializer:
If this method is called more than once with the same library name, the second and subsequent calls are ignored.
getLocalizedInputStream
If the argument is already a localized stream, it may be returned as the result.
getLocalizedOutputStream
If the argument is already a localized stream, it may be returned as the result.
- Summary:
- Nested |
- Field |
- Constr |
- Method
- Detail:
- Field |
- Constr |
- Method
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2021, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.
Источник
Jake Wharton
Android’s Java 9, 10, 11, and 12 Support
27 November 2018
Note: This post is part of a series on D8 and R8, Android’s new dexer and optimizer, respectively. For an intro to D8 read “Android’s Java 8 support”.
The first post in this series explored Android’s Java 8 support. Having support for the language features and APIs of Java 8 is table stakes at this point. We’re not quite there with the APIs yet, sadly, but D8 has us covered with the language features. There’s a future promise for the APIs which is essential for the health of the ecosystem.
A lot of the reaction to the previous post echoed that Java 8 is quite old. The rest of the Java ecosystem is starting to move to Java 11 (being the first long-term supported release after 8) after having toyed with Java 9 and 10. I was hoping for that reaction because I mostly wrote that post so that I could set up this one.
With Java releases happening more frequently, Android’s yearly release schedule and delayed uptake of newer language features and APIs feels more painful. But is it actually the case that we’re stuck with those of Java 8? Let’s take a look at the Java releases beyond 8 and see how the Android toolchain fares.
Java 9
The last release on the 2 — 3 year schedule, Java 9 contains a few new language features. None of them are major like lambdas were. Instead, this release focused on cleaning up some of the sharp edges on existing features.
Concise Try With Resources
Prior to this release the try-with-resources construct required that you define a local variable (such as try (Closeable bar = foo.bar()) ). But if you already have a Closeable , defining a new variable is redundant. As such, this release allows you to omit declaring a new variable if you already have an effectively-final reference.
This feature is implemented entirely in the Java compiler so D8 is able to dex it for Android.
Unlike the lambdas or static interface methods of Java 8 which required special desugaring, this Java 9 feature becomes available to all API levels for free.
Anonymous Diamond
Java 7 introduced the diamond operator which allowed omitting a generic type from the initializer if it could be inferred from the variable type.
This cut down on redundant declarations, but it wasn’t available for use on anonymous classes. With Java 9 that is now supported.
Once again this is entirely implemented in the Java compiler so the resulting bytecode is as if String was explicitly specified.
Because there is nothing interesting in the bytecode, D8 handles this without issue.
Yet another language feature available to all API levels for free.
Private Interface Methods
Interfaces with multiple static or default methods can often lead to duplicated code in their bodies. If these methods were part of a class and not an interface private helper functions could be extracted. Java 9 adds the ability for interfaces to contain private methods which are only accessible to its static and default methods.
This is the first language feature that requires some kind of support. Prior to this release, the private modifier was not allowed on an interface member. Since D8 is already responsible for desugaring default and static methods, private methods were straightforward to include using the same technique.
Static and default methods are supported natively in ART as of API 24. When you pass —min-api 24 for this example, the static method is not desugared. Curiously, though, the private static method is also not desugared.
We can see that the getHey() method’s access flags still contain both PRIVATE and STATIC . If you add a main method which calls hey() and push this to a device it will actually work. Despite being a feature added in Java 9, ART allows private interface members since API 24!
Those are all the language features of Java 9 and they all already work on Android. How about that.
The APIs of Java 9, though, are not yet included in the Android SDK. A new process API, var handles, a version of the Reactive Streams interfaces, and collection factories are just some of those which were added. Since libcore (which contains implementation of java.* ) and ART are developed in AOSP, we can peek and see that work is already underway towards supporting Java 9. Once included included in the SDK, some of its APIs will be candidates for desugaring to all API levels.
String Concat
The new language features and APIs of a Java release tend to be what we talk about most. But each release is also an opportunity to optimize the bytecode which is used to implement a feature. Java 9 brought an optimization to a ubiquitous language feature: string concatenation.
If we take this fairly innocuous piece of code and compile it with Java 8 the resulting bytecode will use a StringBuilder .
The bytecode contains the code we otherwise would have written if the language didn’t allow simple concatenation.
If we change the compiler to Java 9, however, the result is very different.
The entire StringBuilder usage has been replaced with a single invokedynamic bytecode! The behavior here is similar to how native lambdas work on the JVM which was discussed in the last post.
At runtime, on the JVM, the JDK class StringConcatFactory is responsible for returning a block of code which can efficiently concatenate the arguments and constants together. This allows the implementation to change over time without the code having to be recompiled. It also means that the StringBuilder can be pre-sized more accurately since the argument’s lengths can be queried.
If you want to learn more about why this change was made, Aleksey ShipilГ«v gave a great presentation on the motivations, implementation, and resulting benchmarks of the change.
Since the Android APIs don’t yet include anything from Java 9, there is no StringConcatFactory available at runtime. Thankfully, just like it did for LambdaMetafactory and lambdas, D8 is able to desugar StringConcatFactory for concatenations.
This means that all of the language features of Java 9 can be used on all API levels of Android despite changes in the bytecode that the Java compiler emits.
But Java is now on a six-month release schedule making Java 9 actually two versions old. Can we keep it going with newer versions?
Java 10
The only language feature of Java 10 was called local-variable type inference. This allows you to omit the type of local variable by replacing it with var when that type can be inferred.
This is another feature implemented entirely in the Java compiler.
No new bytecodes or runtime APIs are required for this feature to work and so it can be used for Android just fine.
Of course, like the versions of Java before it, there are new APIs in this release such as Optional.orElseThrow , List.copyOf , and Collectors.toUnmodifiableList . Once added to the Android SDK in a future API level, these APIs can be trivially desugared to run on all API levels.
Java 11
Local-variable type inference was enhanced in Java 11 to support its use on lambda variables. You don’t see types used in lambda parameters often so a lot of people don’t even know this syntax exists. This is useful when you need to provide an explicit type to help type inference or when you want to use a type-annotation on the parameter.
Just like Java 10’s local-variable type inference this feature is implemented entirely in the Java compiler allowing it to work on Android.
New APIs in Java 11 include a bunch of new helpers on String , Predicate.not , and null factories for Reader , Writer , InputSteam , and OutputStream . Nearly all of the API additions in this release could be trivially desugared once available.
A major API addition to Java 11 is the new HTTP client, java.net.http . This client was previously available experimentally in the jdk.incubator.http package since Java 9. This is a very large API surface and implementation which leverages CompletableFuture extensively. It will be interesting to see whether or not this even lands in the Android SDK let alone is available via desugaring.
Nestmates
Like Java 9 and its string concatenation bytecode optimization, Java 11 took the opportunity to fix a long-standing disparity between Java’s source code and its class files and the JVM: nested classes.
In Java 1.1, nested classes were added to the language but not the class specification or JVM. In order to work around the lack of support in class file, nesting classes in a source file instead creates sibling classes which use a naming convention to convey nesting.
Compiling this with Java 10 or earlier will produce two class files from a single source file.
As far as the JVM is concerned, these classes have no relationship except that they exist in the same package.
This illusion mostly works. Where it starts to break down is when one of the classes needs to access something that is private in the other.
When these classes are made siblings, Outer$Inner.sayHi() is unable to access Outer.name because it is private to another class.
In order to work around this problem and maintain the nesting illusion, the Java compiler adds a package-private synthetic accessor method for any member accessed across this boundary.
This is visible in the compiled class file for Outer .
Historically this has been at most a small annoyance on the JVM. For Android, though, these synthetic accessor methods contribute to the method count in our dex files, increase APK size, slow down class loading and verification, and degrade performance by turning a field lookup into a method call!
In Java 11, the class file format was updated to introduce the concept of nests to describe these nesting relationships.
The output here has been trimmed significantly, but the two class files are still produced except without an access$000 in Outer and with new NestMembers and NestHost attributes. These allow the VM to enforce a level of access control between package-private and private called nestmates. As a result, Inner can directly access Outer ’s name field.
ART does not understand the concept of nestmates so it needs to be desugared back into synthetic accessor methods.
Unfortunately, at the time of writing, this does not work. The version of ASM, the library used to read Java class files, predates the final implementation of nestmates. Beyond that, though, D8 does not support desugaring of nest mates. You can star the D8 feature request on the Android issue tracker to convey your support for this feature.
Without support for desugaring nestmates it is currently impossible to use Java 11 for Android. Even if you avoid accessing things across the nested boundary, the mere presence of nesting will fail to compile.
Without the APIs from Java 11 in the Android SDK, its single language feature of lambda parameter type inference isn’t compelling. For now, Android developers are not missing anything by being stuck on Java 10. That is, until we start looking forward…
Java 12
With a release date of March 2019, Java 12 is quickly approaching. The language features and APIs of this release have been in development for a few months already. Through early-access builds, we can download and experiment with these today.
In the current EA build, number 20, there are two new language features available: expression switch and string literals.
Once again, both of these features are implemented entirely as part of the Java compiler without any new bytecodes or APIs.
We can push this to a device to ensure that it actually works at runtime.
This works because the bytecode for expression switch is the same as the “regular” switch we would otherwise write with an uninitialized local, case blocks with break , and a separate return statement. And a multi-line string literal is just a string with newlines in it, something we’ve been able to do with escape characters forever.
As with all the other releases covered, there will be new APIs in Java 12 and it’s the same story as before. They’ll need added to the Android SDK and evaluated for desugaring capability.
Hopefully by the time Java 12 is actually released D8 will have implemented desugaring for Java 11’s nestmates. Otherwise the pain of being stuck on Java 10 will go up quite a bit!
Java 8 language features are here and desugaring of its APIs are coming (star the issue!). As the larger Java ecosystem moves forward to newer versions, it’s reassuring that every language feature between 8 and 12 is already available on Android.
With Java 9 work seemingly happening in AOSP (cross your fingers for Android P+1), hopefully we’ll have a new batch of APIs in the summer as candidates for desugaring. Once that lands, the smaller releases of Java will hopefully yield faster integration into the Android SDK.
Despite this, the end advice remains the same as in the last post. It’s vitally important to maintain pressure on Android for supporting the new APIs and VM features from newer versions of Java. Without APIs being integrated into the SDK they can’t (easily) be made available for use via desugaring. Without VM features being integrated into ART D8 bears a desugaring burden for all API levels instead of only to provide backwards compatibility.
Before these posts move on to talk about R8, the optimizing version of D8, the next one will cover how D8 works around version-specific and vendor-specific bugs in the VM.
(This post was adapted from a part of my Digging into D8 and R8 talk that was never presented. Watch the video and look out for future blog posts for more content like this.)
Источник