Java 9

https://blog.takipi.com/the-top-10-jigsaw-and-java-9-misconceptions-debunked/


https://www.voxxed.com/2016/11/java-9-series-variable-handles/
https://dzone.com/articles/3-tips-for-volatile-fields-in-java

All modern CPUs provide instructions to atomically compare and set or increment and get values. Those operations are used internally by the JVM to implement synchronized locks. Prior to JDK 1.9, they were available for Java applications only through classes in the java.util.concurrent.atomic package or by using the private java API sun.misc.Unsafe. With the new JDK 9 VarHandle, it is now possible to execute such operations directly on volatile fields. The following shows the AtomicBoolean compareAndSet method implemented using VarHandles:

public class AtomicBoolean implements java.io.Serializable {

    private static final VarHandle VALUE;

    static {

        try {

            MethodHandles.Lookup l = MethodHandles.lookup();

            VALUE = l.findVarHandle(AtomicBoolean.class, "value", int.class);

        } catch (ReflectiveOperationException e) {

            throw new Error(e);

        }

    }

    private volatile int value;

    public final boolean compareAndSet(boolean expectedValue, boolean newValue) {

        return VALUE.compareAndSet(this,

            (expectedValue ? 1 : 0),

            (newValue ? 1 : 0));

    }

    // Other fields and methods omitted

}

The VarHandle works similarly to the class java.lang.reflect.Field. You need to look up a VarHandle from the class that contains the field using the name of the field, line 6. To execute a compareAndSet operation on the field, we need to call the VarHandle with the object of the field, the expected and the new value, line 13.

Variable handles are a new feature of Java 9 that allow you to get a typed reference to a variable (attribute, static field, or array element) in order to access it in different modes.

VarHandle handler;
try {
  handler = MethodHandles.lookup().in(Account.class)
              .findVarHandle(Account.class, "amount",
              double.class);
  for (int i = 0; i < 10000; i++) {
    handler.getAndAdd(account, -100);
    account.unsafeAmount -= 100;
  }
} catch (NoSuchFieldException | IllegalAccessException e) {
  e.printStackTrace();
}
Read mode: This is used to get read mode access to a variable. You can use the following methods:
get(): Read the value of the variable as if it was declared non-volatile
getVolatile(): Read the value of the variable as if it was declared volatile
getAcquire(): Read the value of the variable and guarantee that the following instructions that modify or access this variable are not reordered before the instructions for optimization purposes
getOpaque(): Read the value of variable and guarantee that the instructions of the current thread are not reordered; no guarantee is provided for other threads
Write mode: This is used to get write access mode to a variable. You can use the set(), setVolatile(), setRelease(), and setOpaque() methods. They are equivalent to the previous ones but with write access.
Atomic access mode: This is used to get a functionality that is similar to the one provided by the atomic variables with operations to, for example, compare and get the value of the variable. You can use the following methods:
compareAndSet(): Change the value of the variable as it was declared as a volatile variable if the expected value passed as parameter is equal to the current value of the variable
weakCompareAndSet() and weakCompareAndSetVolatile(): Possibly atomically' changes the value of the variable as it was declared as non-volatile or volatile variables respectively if the expected value passed as parameter is equals to the current value of the variable
Numerical update access mode: This is to modify numerical values in an atomic way.

https://www.pluralsight.com/blog/software-development/java-9-new-features
Modular JAR files contain an additional module descriptor. In this module descriptor, dependencies on other modules are expressed through`requires` statements. Additionally, `exports` statements control which packages are accessible to other modules. All non-exported packages are encapsulated in the module by default

module blog {
  exports com.pluralsight.blog;

  requires cms;
}

By encapsulating JDK internal classes, the platform is more secure and evolving it becomes much easier.

2. Linking

the new jlink tool in Java 9. Instead of shipping your app with a fully loaded JDK installation, you can create a minimal runtime image optimized for your application.

5. Collection factory methods

Set<Integer> ints = Set.of(1, 2, 3);
List<String> strings = List.of("first", "second");

the collection implementations returned from the factory methods are highly optimized for the number of elements you put in. That's possible because they're immutable: adding items to these collections after creation results in an `UnsupportedOperationException`.




6. Stream API improvements

The Streams API is arguably one of the best improvements to the Java standard library in a long time. It allows you to create declarative pipelines of transformations on collections. With Java 9, this only gets better. There are four new methods added to the Stream interface: dropWhile, takeWhile, ofNullable. The iterate method gets a new overload, allowing you to provide a Predicate on when to stop iterating:

IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println);

The second argument is a lambda that returns true until the current element in the IntStream becomes 100. This simple example therefore prints the integers 1 until 99 on the console.

Besides these additions on Stream itself, the integration between Optional and Stream has been improved. It's now possible to turn an Optional object into a (possibly empty) Stream with the new `stream` method on Optional:

Stream<Integer> s = Optional.of(1).stream();

Turning an Optional into a Stream is especially useful when composing complex Streampipelines.

7. Private interface methods

8. HTTP/2

The new HttpClient API is delivered as a so-called _incubator module_ in Java 9. This means the API isn't guaranteed to be 100% final yet. Still, with the arrival of Java 9 you can already start using this API:

HttpClient client = HttpClient.newHttpClient();

HttpRequest req =
   HttpRequest.newBuilder(URI.create("http://www.google.com"))
              .header("User-Agent","Java")
              .GET()
              .build();


HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());

9. Multi-release JARs

multirelease.jar
├── META-INF
│   └── versions
│       └── 9
│           └── multirelease
│               └── Helper.class
├── multirelease
    ├── Helper.class
    └── Main.class

In this case, multirelease.jar can be used on Java 9, where instead of the top-level multirelease.Helper class, the one under `META-INF/versions/9` is used. 

http://www.baeldung.com/new-java-9

URI httpURI = new URI("http://localhost:8080");

HttpRequest request = HttpRequest.create(httpURI).GET();

HttpResponse response = request.response();

String responseBody = response.body(HttpResponse.asString());

The process API has been improved for controlling and managing operating-system processes.

The class java.lang.ProcessHandle contains most of the new functionalities:

1 2 3 4 5 6 7 8

ProcessHandle self = ProcessHandle.current(); long PID = self.getPid(); ProcessHandle.Info procInfo = self.info();    Optional<String[]> args = procInfo.arguments(); Optional<String> cmd =  procInfo.commandLine(); Optional<Instant> startTime = procInfo.startInstant(); Optional<Duration> cpuUsage = procInfo.totalCpuDuration();

5.1. Try-With-Resources

In Java 7, the try-with-resources syntax requires a fresh variable to be declared for each resource being managed by the statement.

In Java 9 there is an additional refinement: if the resource is referenced by a final or effectively final variable, a try-with-resources statement can manage a resource without a new variable being declared:

1 2 3 4 5 6 7 8

MyAutoCloseable mac = new MyAutoCloseable(); try (mac) {     // do some stuff with mac }    try (new MyAutoCloseable() { }.finalWrapper.finalCloseable) {    // do some stuff with finalCloseable } catch (Exception ex) { }

Another interesting subcommand is set_vmflag. We can modify some JVM parameters online, without the need of restarting the JVM process and modifying its startup parameters.

You can find out all the available VM flags with subcommand jcmd 14056 VM.flags -all

https://www.journaldev.com/13121/java-9-features-with-examples

Executor exe = CompletableFuture.delayedExecutor(50L, TimeUnit.SECONDS);

Here delayedExecutor() is static utility method used to return a new Executor that submits a task to the default executor after the given delay.

Stream<Optional> emp = getEmployee(id)
Stream empStream = emp.flatMap(Optional::stream)

Here Optional.stream() method is used convert a Stream of Optional of Employee object into a Stream of Employee so that we can work on this result lazily in the result code.

jshell> Stream.of(1,2,3,4,5,6,7,8,9,10).takeWhile(i -> i < 5 )
                 .forEach(System.out::println);