Java 10 was released in March 2018, It comes just six months after its predecessor i.e. Java 9 and brings an enhanced Local Variable Type Inference, garbage collection and compilation and other exciting features. It was an enhancement to the Java 9 and its a new polished version of Java 9 as It was not a major update but still it include the important features and modifications such as Native-Header Generation Tool (aka javah) is removed.
Java 8 to Java 9 it took 3 years and after 6 months of Java 9 Oracle released the Java 10. Java community announced its shift to a new 6 month cadence for Java. It moved to a Long Term Support (LTS) model for Oracle Java SE products.
What does LTS mean?
LTS version of the products will offer premier and sustained support from Oracle and it will be targeted every 3 years.
Java 10 features
1. Local-Variable Type Inference :
Local-Variable Type Inference is the biggest new feature in Java 10. It adds type inference to declarations of local variables with initializers. Local type inference can be used only in the following scenarios:
- Limited only to Local Variable with initializer
- Indexes of enhanced for loop or indexes
- Local declared in for loop
2. Consolidate the JDK Forest into a Single Repository
3. Garbage-Collector Interface
Parallel Full GC for G1:
G1 garbage collector was made default in Java 9 (JDK 9). G1 Garbage collector avoids any full garbage collection, but when concurrent threads for collection cannot revive the memory fast enough users experience is impacted.
This change improves the G1 worst-case latency by making the full GC parallel. The mark-sweep-compact algorithm from G1 collector is parallelized as part of this change and will be triggered when concurrent threads for collection can’t revive the memory fast enough.
4. Application Class-Data Sharing :
This feature helps in improving the startup footprint, extends the existing Class-Data Sharing (“CDS”) feature to allow application classes to be placed in the shared archive.
JVM while starting performs some preliminary steps, one of which is loading classes in memory. If there are several jars having multiple classes, then the lag in the first request is clearly visible. This becomes an issue with server less architecture, where boot time is critical. In order to bring down application startup time, Application class-data sharing can be used. The idea is to reduce footprint by sharing common class metadata across different Java processes.
This can be achieved by following 3 steps:
1. Determining the classes to archive: Use the java launcher to create a list of files to archive, this can be achieved by following parameters:
$java -Xshare:off -XX:+UseAppCDS -XX:DumpLoadedClassList=hello.lst -cp hello.jar HelloWorld
2. Creating the AppCDS archive: Use java launcher to create the archive of the list of files to be used for Application CDS, this can be achieved by following parameters:
$java -Xshare:dump -XX:+UseAppCDS -XX:SharedClassListFile=hello.lst -XX:SharedArchiveFile=hello.jsa -cp hello.jar
3. Using the AppCDS archive: Use Java launcher with the following parameters to use Application CDS.
$java -Xshare:on -XX:+UseAppCDS -XX:SharedArchiveFile=hello.jsa -cp hello.jar HelloWorld
4. Thread-Local Handshakes
5. Remove the Native-Header Generation Tool (javah)
6. Additional Unicode Language-Tag Extensions
7. Heap Allocation on Alternative Memory Devices
8. Experimental Java-Based JIT Compiler :
9. Root Certificates
10. Time-Based Release Versioning:
Oracle changed the version-string scheme of the Java SE Platform and the JDK, and related versioning information, for present and future time-based release models.
The new pattern of the Version number is:
$FEATURE. $INTERIM. $UPDATE. $PATCH
Comments
Post a Comment