Les nouveautés de Java 9
Pour les développeurs
Loïc Mathieu - @loicmathieu
JPMS
Project Jigsaw
Les JEPs
JEP 102: Process API Updates
- But : faciliter l'appel à un programme (process) externe depuis Java
- Ajout de nombreuses fonctionnalités à l'API actuelle :
- récupérer le PID,
- killer un process
- récupérer la ligne de commande
- …
- Ajout de ProcessHandle qui permet de gérer le process de la JVM (ProcessHandle.current()) ou un process fils (Runtime.getRuntime().exec(""))
- Compatible avec les différents OS supportés par Java
JEP 102: Process API Updates
// Get PIDs of own processes
System.out.println("Your pid is " + ProcessHandle.current().getPid());
//start a new process and get PID
Process p = Runtime.getRuntime().exec("sleep 1h");
ProcessHandle h = ProcessHandle.of(p.getPid()).orElseThrow(IllegalStateException::new);
// Do things on exiting process : CompletableFuture !
h.onExit().thenRun( () -> System.out.println("Sleeper exited") );
// Get info on process : return Optional!
System.out.printf("[%d] %s - %s\n", h.getPid(), h.info().user().orElse("unknown"),
h.info().commandLine().orElse("none"));
// Kill a process
h.destroy();
JEP 110: HTTP/2 Client (Incubator)
-
HTTP/2 est là, et beaucoup de site l’exploitent déjà.
-
Une nouvelle API a été créée pour proposer une implémentation plus simple à utiliser que la très ancienne HttpURLConnection
-
Nouveau client HTTP au goût du jour, synchrone ou asynchrone (alors basé sur les CompletableFuture).
- Disponible dans le module "incubator"
JEP 110: HTTP/2 Client (Incubator)
/**
* The HTTP API functions asynchronously and synchronously.
* In asynchronous mode, work is done in threads (ExecutorService).
*/
public static void main(String[] args) throws Exception {
HttpClient.getDefault()
.request(URI.create("http://www.loicmathieu.fr"))
.GET()
.responseAsync() // CompletableFuture
.thenAccept(httpResponse ->
System.out.println(httpResponse.body(HttpResponse.asString()))
);
Thread.sleep(999); // Give worker thread some time.
}
JEP 259: Stack-Walking API
Stack-Walking API : une nouvelle API pour parcourir une stack d'execution.
JEP 259: Stack-Walking API
// return class/method only for our classes.
private static List<String> walkAndFilterStackframe() {
return StackWalker.getInstance().walk(s ->
s.map( frame -> frame.getClassName() + "/" + frame.getMethodName())
.filter(name -> name.startsWith("fr.loicmathieu"))
.limit(10)
.collect(Collectors.toList()) );
}
JEP 269: Convenience Factory Methods for Collections
-
L'un des plus grand changement en terme d’API : des méthodes statiques pour la création de collection immuable.
-
Cible : création de petite collections (list, set, map).
- La performance et l’utilisation mémoire ont été au centre de l’implémentation de ces collections.
JEP 269: Convenience Factory Methods for Collections
List<Integer> listOfNumbers = List.of(1, 2, 3, 4, 5);
Set<Integer> setOfNumbers = Set.of(1, 2, 3, 4, 5);
Map<String, String> mapOfString =
Map.of("key1", "value1", "key2", "value2");
Map<String, String> moreMapOfString =
Map.ofEntries(
Map.entry("key1", "value1"),
Map.entry("key2", "value2"),
Map.entry("key1", "value3")
);
JEP 266: More Concurrency Updates
Implémentation des Reactive Stream en Java via la classe Flow :
- Publisher : Produit des messages que les subscriber vont consommer. La seule méthode est subscribe(Subscriber).
- Subscriber : Souscrit a un publisher pour recevoir des messages (via la methode onNext(T)), des messages d’erreur (onError(Throwable)), ou un signal comme quoi il n’y aura plus de messages (onComplete()). Avant toute chose, le publisher doit appeler onSubscription(Subscription).
- Subscription : La connexion entre un publisher et un subscriber. Le subscriber va l’utiliser pour demander des messages (request(long)) ou pour rompre la connexion (cancel()).
Flow
JEP 266: More Concurrency Updates
public class MySubscriber<T> implements Subscriber<T> {
private Subscription subscription;
@Override
public void onSubscribe(Subscription subscription) {
this.subscription = subscription;
subscription.request(1);
}
@Override
public void onNext(T item) {
System.out.println("Got : " + item);
subscription.request(1);
}
@Override
public void onError(Throwable t) {
t.printStackTrace();
}
@Override
public void onComplete() {
System.out.println("Done");
}
}
Flow
JEP 266: More Concurrency Updates
//Create Publisher
SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
//Register Subscriber
MySubscriber<String> subscriber = new MySubscriber<>();
publisher.subscribe(subscriber);
//Publish items
System.out.println("Publishing Items...");
String[] items = {"1", "x", "2", "x", "3", "x"};
Arrays.asList(items).stream().forEach(i -> publisher.submit(i));
publisher.close();
Flow
JEP 266: More Concurrency Updates
Quelques changements à l’API CompletableFuture ont vu le jour permettant, entre autre, une meilleur composition des CompletableFuture entre elles :
-
copy():CompletableFuture<T>
-
completeAsync(Supplier<? extends T> supplier):CompletableFuture<T>
-
orTimeout(long timeout,TimeUnit unit):CompletableFuture<T>
-
completeOnTimeout(T value, long timeout, TimeUnit unit):CompletableFuture<T>
-
failedFuture(Throwable ex):CompletableFuture<T>
CompletableFuture
JEP 277: Enhanced Deprecation
Ajout de deux attributs à l'annotation @Deprecated :
- since : depuis quelle version l'API est dépréciée.
- forRemoval : mettre à true (par défaut false) si l'API sera supprimée dans une future release.
Le but est de faciliter le cycle de vie des applications et de permettre, peut-être plus sereinement, de supprimer dans le futur certaines API du JDK lui-même.
JEP 277: Enhanced Deprecation
@Deprecated(since="9", forRemoval=true)
public class MyDeprecatedClass {
//deprecated stuff
}
JEP 222: jshell: The Java Shell (Read-Eval-Print Loop)
Beaucoup de languages (ruby, scala, python, …) proposent une Read-Evaluate-Print-Loop (REPL), un shell.
Celà permet un apprentissage aisé du language et donne une porte d’entré direct depuis un simple shell.
Eviter le cérémonial d’édition, de compilation, de packaging du code.
Avec Java 9, apparait jshell, le REPL de java !
Depuis une ligne de commande, exécutez <java_home>/bin/jshell et laissez vous guider par l’aide (/help). Exemple ci-dessous :
JEP 222: jshell: The Java Shell (Read-Eval-Print Loop)
JEP 213: Milling Project Coin
Project Coin est un projet d’évolution du language, qui a débuté avec java 7 dans le but de simplifier l’utilisation du language pour les développeurs en apportant des petites modifications de l’ordre du « sucre syntaxique ».
La JEP213 : Milling Project Coin contient l’implémentation dans Java 9 des dernières partie du projet.
JEP 213: Milling Project Coin
-
@SafeVarargs autorisé sur une méthode privé (précédemment uniquement dans les méthodes static ou finale)
- Autorisation de l’opérateur <> pour les classes abstraite (quand le type est dénotable)
- Suppression de ‘_’ comme un identificateur valide pour permettre sa réutilisation en Java 10
- Méthode privé dans les interfaces : permet la factorisation de code de méthode statique dans une même interface.
JEP 213: Milling Project Coin
Avant Java 9 :
final Resource r = new Resource();
try (Resource r2 = r) { … }
Après Java 9 :
final Resource r = new Resource();
try (r) { … // Cannot mutate r }
- Autorisation des variables finale (ou effectivement finale) dans un try-with-resource (exemple ci-dessous) :
Pleins d’autres changements hors JEP
Stream
- Stream.takeWhile(Predicate<? super T> predicate):Stream<T> : construit une stream qui contient les éléments de la première tant que le prédicat est vrai. Dès que le prédicat devient faux la stream est coupée.
- Stream.dropWhile(Predicate<? super T> predicate):Stream<T> : l’inverse de takeWhile, construit une stream qui contient le premier élément faux puis les suivants. Tant que le prédicat est faux : supprime les émélments, dès qu’il est vrai, inclue les éléments dans la stream.
- Stream.ofNullable(T element):Stream<T> : retourne une stream avec l’élément ou une stream vide si l’élément est nulle. Evite l’utilisation d’Optional avec les stream
- Stream.iterate(T, Predicate<? super T>, UnaryOperator<T>) : réplique une boucle for standard : Stream.iterate(0; i -> i<10, i -> i+1)
Stream
//iterate
/java 8 style : using for loop
for (int i = 0; i < 10; ++i) {
System.out.println(i);
}
//java 9 style, using Stream.iterate
Stream.iterate(0, i -> i < 10, i -> i + 1).forEach(System.out::println);
//takeWhile and dropWhile
Stream<String> stream = Stream.iterate("", s -> s + "s")
stream.takeWhile(s -> s.length() < 10);
stream.dropWhile(s -> !s.contains("sssss"));
//ofNullable : returning Stream.empty() for null element
//java 8 style : we need to make a check to know if it's null or not
collection.stream()
.flatMap(s -> {
Integer temp = map.get(s);
return temp != null ? Stream.of(temp) : Stream.empty();
})
.collect(Collectors.toList());
//java 9 style
collection.stream().flatMap(s -> Stream.ofNullable(map.get(s))).collect(Collectors.toList());
Collectors
-
Collectors.filtering(Predicate<? super T>,Collector<? super T,A,R>) : execute un filtre en amont du collector (voir un exemple dans la Javadoc qui explique la différence avec l’utilisation de Stream.filter() avant l’utilisation d’un collector)
- Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>>,Collector<? super U,A,R>) : execute une operation de type flatMap en amont du collector (voir un exemple concret dans la Javadoc)
Collectors
List<Integer> numbers = List.of(1, 2, 3, 5, 5);
Map<Integer, Long> result = numbers.stream()
.filter(val -> val > 3)
.collect(Collectors.groupingBy(i ->; i, Collectors.counting()));
result = numbers.stream()
.collect(Collectors.groupingBy(i -> i,
Collectors.filtering(val -> val > 3, Collectors.counting())
));
Optional
4 nouvelles méthodes ont été ajoutée à la classe Optional :
- or(Supplier):Optional : retourne le même Optional ou un Optional construit avec le Supplier passé en paramètre si il n’y a pas de valeur. Cela permet une construction lazy d’un autre Optional si la valeur du premier n’existe pas.
- ifPresent(Consumer):void : execute le Consumer en paramètre s’il y a une valeur de présente
- ifPresentOrElse(Consumer, Runnable):void : execute le Consumer en paramètre s’il y a une valeur de présente sinon execute le Runnable
- stream():Stream<T> : retourne un Stream d’un element s’il y a une valeur ou un Stream vide. Cela permet l’utilisation de l’API Stream avec les Optional.
Optional
//Optional.or : a lazy version of orElse
Optional<String> value = ...;
Optional<String> defaultValue = Optional.of(() -> bigComputation());
return value.or(defaultValue);//bigComputation will be called only if value is empty
//Optional.ifPresent :
Optional<String> value = ...;
AtomicInteger successCounter = new AtomicInteger(0);
value.ifPresent(
v -> successCounter.incrementAndGet());
//Optional.ifPresentOrElse :
Optional<String> value = ...;
AtomicInteger successCounter = new AtomicInteger(0);
AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0);
value.ifPresentOrElse(
v -> successCounter.incrementAndGet(),
onEmptyOptionalCounter::incrementAndGet);
//Optional.stream : unify the stream and Optional API
Optional<String> value = Optional.of("a");
List<String> collect = value.stream().map(String::toUpperCase).collect(Collectors.toList());
//["A"]
Java Time
Plusieurs ajouts à l’API Java Time, entre autre la possibilité de créer un Stream de date avec :
-
LocalDate.datesUntil(LocalDate)
-
LocalDate.datesUntil(LocalDate,Period)
InputStream
-
InputStream.readAllBytes():byte[] : lit d’un seul coup un input stream en tableau de byte
- InputStream.readNBytes(byte[] b, int off, int len):int : lit d’un seul coup un input stream dans le tableau de byte en paramètre avec offset et limite.
Objects
- Objects.requireNonNullElse(T obj, T defaultObj) : retourne le premier éléments si non null, sinon le deuxième. Si les deux sont null : NullPointerException !
- Objects.requireNonNullElseGet(T obj, Supplier supplier) : retourne le premier éléments si non null, sinon appel le supplier.get().
- int Objects.checkIndex(int index, int length) : check de l’index : génère un IndexOutOfBoundsException si l’index est inférieur à 0 ou supérieur ou éagle à la taille. Cette méthode peut-être optimisée par le JVM.
- int Objects.checkFromToIndex(int fromIndex, int toIndex, int length) : idem mais pour le sous-range fromIndex/toIndex
- int Objects.checkFromIndexSize(int fromIndex, int size, int length) : idem mais pour le sous-range fromIndex/fromIndex + size
Math, StrictMath, BigDecimal, BigInteger
-
{Math, StrictMath}.fma() : implémentation de l’opération fused-multiply-accumulate (fma)
-
{Math, StrictMath}.{multiplyExact, floorDiv, floorMod}
- {BigDecimal, BigInteger}. sqrt() : racine carré
Arrays
Beaucoup de nouvelles méthodes permettant de comparer des tableaux :
-
Arrays.equals()
-
Arrays.compare()
-
Arrays.compareUnsigned()
-
Arrays.mismatch()
Et plus encore
Performance
Voici une liste de JEP de Java 9 axés performances :
- JEP 143: Improve Contended Locking : optimisation des monitors Java (optimisation des lock).
- JEP 193: Variable Handles : C++ atomics …
- JEP 197: Segmented Code Cache : le code cache (une partie du Metaspace) a été séparé pour en optimiser les performances.
- JEP 274: Enhanced Method Handles : plusieurs ajout à l’API MethodHandle
- JEP 285: Spin-Wait Hints : pour les utilisateurs bas niveau uniquement : possibilité de préciser à la JVM qu’on est dans une spin-wait-loop …
Performance
-
JEP 254: Compact Strings : revue de l’implémentation des String en Java pour en proposer une version plus compact en cas de Sring ISO-8859-1 (ou Latin-1).
- UTF16 : chaque caractère est stocké sur deux octets.
- ISO-8859-1 chaque caractère est stocké sur un octets.
- JEP 280: Indify String Concatenation : intrasification de la concaténation des chaînes de caractère dans le JVM.
Démarrage
Beaucoup de travail a été fait pour optimiser le démarrage de Java en terme de temps de démarrage de la JVM et d'empreinte mémoire mené par Claes Redestad (Oracle).
L'implémentation de la modularisation a potentiellement ralenti le démarrage de java 9 : attention test réalisé sur une version non définitive de Java 9 !
Démarrage
Des tests réalisés en comparaison d'un Java 9EAb176 et d'un Java 8u144 ont montré que :
- Java démarre très vite (<100ms pour un HelloWorld)
- Java démarre plus lentement (2.5x) quand utilisation d'une lambda et nécessite 2Mo en plus
- En java 9 : la différence entre utilisation ou pas de lambda se réduit (et c'est presque plus rapide qu'en java 8)
- Java 9 démarre plus lentement que Java 8 et prend plus de mémoire
- Lenteur : Est-ce la cause de JPMS ?
- Mémoire : G1 par défaut en est la cause
Démarrage
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
public class HelloWorldLambda {
public static void main(String[] args) {
Runnable hello = () -> System.out.println("Hello lambda world");
hello.run();
}
}
Démarrage
Les tests en détails : http://www.loicmathieu.fr/wordpress/informatique/demarrage-jvm-8-vs-9/
time java HelloWorld
real 0m0.085s
user 0m0.078s
sys 0m0.019s
time java HelloWorldLambda
real 0m0.185s
user 0m0.236s
sys 0m0.032s
java -XX:+UnlockDiagnosticVMOptions \
-XX:NativeMemoryTracking=summary \
-XX:+PrintNMTStatistics \
-Xmx16m -Xms16m HelloWorld
Total: reserved=1356124KB, committed=57156KB
java -XX:+UnlockDiagnosticVMOptions \
-XX:NativeMemoryTracking=summary \
-XX:+PrintNMTStatistics \
-Xmx16m -Xms16m HelloWorldLambda
Total: reserved=1358869KB, committed=59901KB
time java HelloWorld
real 0m0.161s
user 0m0.177s
sys 0m0.048s
time java HelloWorldLambda
real 0m0.199s
user 0m0.228s
sys 0m0.042s
java -XX:+UnlockDiagnosticVMOptions \
-XX:NativeMemoryTracking=summary \
-XX:+PrintNMTStatistics \
-Xmx16m -Xms16m HelloWorld
Total: reserved=1389612KB, committed=97536KB
java -XX:+UnlockDiagnosticVMOptions \
-XX:NativeMemoryTracking=summary \
-XX:+PrintNMTStatistics \
-Xmx16m -Xms16m HelloWorldLambda
Total: reserved=1390008KB, committed=98188KB
Crédits
Cette présentation est inspirée de l'article :
http://www.loicmathieu.fr/wordpress/informatique/les-nouveautes-de-java-9-pour-les-developeurs/
Cet article est lui-même inspiré de :
https://blogs.oracle.com/darcy/resource/Devoxx/DevoxxUS-2017-jdk9-lang-tools-libs.pdf
http://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-BA9D8AF6-E706-4327-8909-F6747B8F35C5
http://blog.takipi.com/5-features-in-java-9-that-will-change-how-you-develop-software-and-2-that-wont/
https://bentolor.github.io/java9-in-action
http://www.javaworld.com/article/2598480/core-java/why-developers-should-get-excited-about-java-9.html
https://www.sitepoint.com/ultimate-guide-to-java-9/
http://www.javamagazine.mozaicreader.com/JulyAug2017
Merci !
&
Question ?
Loïc Mathieu - @loicmathieu
Java 9
By loicmathieu
Java 9
- 1,425