Programmation asynchrone et barre de progression

Le Framework .NET 4.5 a apporté une nouveauté assez géniale : await/async.

Cette nouveauté permet de manipuler les tâches asynchrone d’une manière facilitée, et surtout sécurisée.
Facilité parce qu’il suffit de ne retenir que trois mots Task, async, await.
Sécurisé car il est presque impossible d’avoir un deadlock quand on utilise les décorateurs async/await alors qu’on fait du multithread.

Le code de base est celui-ci :

Il est absoluement nécessaire d’avoir dans votre fonction un await quelque part.
L’effet de await est globalement de lancer la tâche, attendre qu’elle finisse, prendre son résultat et le retourner sans se soucier de l’encapsulation sous forme de Task.
L’avantage principal, c’est que le temps qu’il passe à attendre… il n’utilise pas de ressource processeur.
Ce qui peut s’avérer une très bonne chose si votre tâche demande beaucoup d’attente (communication avec une BDD, un service web…)
Continue reading

Comment un langage lambda peut-il devenir cool?

Dans ce titre un peu étrange se cache un certain enthousiasme : le Java qui m’énerve, me fait râler, me fait faire des choses répétitives, crades (classes anonymes) mais pourtant si stricte qu’on dirait un grand père réac est en train, enfin, de disparaître. Une nouvelle fonctionnalité, les lambda functions arrivera avec Java 1.8 et j’avoue qu’à mon sens ces expressions sont crées en Java de la plus belle manière qui soit, petit aperçu.

Ce qui importe : les parties codantes

J’ai assisté au Ch’ti JUG mardi dernier, la conférence était animé par Rémi FORAX qui a d’emblée mis le doigt sur un problème important en JAVA : la part très importante de cérémonie et de code superflu face aux parties codantes. Eh oui, plus que la déclaration des classes et des fonctions, en JAVA vous pouvez surcharger votre ligne de code avec des “cérémonies” très -trop- nombreuses.

L’idée est donc d’incorporer des fonctionnalités qui feront que les parties codantes seront vraiment plus importantes. Premièrement, on va essayer d’arrêter de créer des classes anonymes quand on veut juste une expression. En plus d’être très inefficace pour différentes raisons (accès disque multipliés…) cela prend pas mal de temps à coder, et en plus c’est difficilement parallélisable. Alors on va créer les fonctions lambda et les expressions statiques.

Par exemple, pour reprendre ce que nous a montré R.Forax, pour lister tous les dossiers contenus dans le dossier courant, la “vieille version” consistait en cela :
[cc lang=”java”]
public class DirectoryLister{
public static File[] listDirectory(File rootDir){
File[] files = rootDir.listFiles(new FileFilter(){
@Override
public boolean accept(File path){
return path.isDirectory();
}
});
return files;
}
public static void main(String[] args){
File root = new File(".");
for(File f: listDirectory(rootDir)){
System.out.println(f);
}
}
}[/cc]
Avec les lambda on peut faire, a première vue :
[cc lang=”java”]
public static File[] listDirectory(File rootDir){
File[] files = rootDir.listFiles((File file)->file.isDirectory());
return files;
}
[/cc]
La syntaxe pour une lambda est [cci lang=”java”](Type1 var1,Type2 var2)->expression[/cci] et si vous avez besoin de plus de lignes :
[cc lang=”java”](Type1 var1,Type2 var2)->{
var1.fonction();
var2.fonction();
return /* ce qu’il y a a retourner*/;
}[/cc]
Mieux encore, comme dans notre exemple il s’agit simplement d’appeler une fonction de l’objet de type File, on peut réduire [cci lang=”java”](File file)->file.isDirectory()[/cci] à
[cci lang=”java”]File::isDirectory[/cci].

Là où Java devient cool : les Stream

Presque tous les langages dynamiques possèdent les fonctions lambda, peu importe leur nom. Mais en Java, quand on réforme le langage (car derrière les lambda, il y a un vrai gros changement de Java quand même), on ne le fait pas pour si peu…
Alors on va créer l’idée des “Streams” et là c’est vraiment immense.
Pour expliquer ce qu’est un stream, rien de mieux qu’un schéma (merci V.Plantevin). Partons d’une collection, un tableau par exemple. Nous voulons le filtrer puis faire une opération sur chaque élément restant.
Les filtres sont dit “méthodes intermédiaires”, alors que le “foreach” est dit “méthode finale”.flux7L’idée c’est que les méthodes intermédiaires vont créer un pipeline extrêmement optimisé et qui peut utiliser toutes les ressources processeur moderne. Ce pipeline n’est construit, à la compilation, que s’il y a une méthode finale : on ne peut pas filtrer un flux sans lui appliquer quelque chose à la fin, sinon le compilateur ne sait pas créer le pipeline.

Alea jacta est

Pour télécharger la dernière version de la JDK 8 :
JDK 8 with lambda
N’hésitez pas à remonter les bugs :
lambda-dev@openjdk.java.net