+ Répondre à la discussion Actualité déjà publiée
  1. #1
    Responsable Java

    Avatar de Mickael Baron
    Homme Profil pro
    Ingénieur de Recherche en Informatique
    Inscrit en
    juillet 2005
    Messages
    11 890
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Ingénieur de Recherche en Informatique
    Secteur : Service public

    Informations forums :
    Inscription : juillet 2005
    Messages : 11 890
    Points : 57 880
    Points
    57 880

    Par défaut Tutoriel pour comparer les performances entre les Java lambdas et les classes anonymes

    SOAT, société d'expertise et de conseil en informatique, et Matthieu Lefèvre, vous propose un tutoriel pour comparer les performances entre les Java lambdas et les classes anonymes en utilisant JMH pour la phase de benchmark.

    Voici l'URL du tutoriel : http://soat.developpez.com/tutoriels...classeanonyme/

    Si vous avez des commentaires, profitez de cette discussion

    Merci d'avance

    L'équipe Java

    Retrouver les meilleurs cours et tutoriels pour apprendre Java : http://java.developpez.com/cours/
    Responsable Java de Developpez.com (Twitter et Facebook)
    Besoin d"un article/tutoriel/cours sur Java, consulter la page cours
    N'hésitez pas à consulter la FAQ Java et à poser vos questions sur les forums d'entraide Java
    --------
    Ingénieur de Recherche en informatique au LIAS / ISAE-ENSMA
    Page de cours : mbaron.developpez.com
    Blog : keulkeul.blogspot.com
    LinkedIn : https://www.linkedin.com/in/mickaelbaron
    Twitter : www.twitter.com/mickaelbaron

  2. #2
    Membre éprouvé

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2005
    Messages
    584
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : juin 2005
    Messages : 584
    Points : 1 213
    Points
    1 213

    Par défaut

    Petite coquille dans la conclusion : Arrays.parallelSort utilise bien l'API fork-join ! et puis les Lambdas utilisent déjà invokeDynamic !

    Arrays.parallelSort(), Stream.parallel() CompletableFuture, etc utilisent un pool de thread fork-Join par défaut dont le nombre de threads possibles est dépendant de Runtime.getRuntime().availableProcessors ! L'auteur utilise un i5-2500K avec 4 CPUs et 4 threads/CPU... par défaut le nombre de threads pour la // sera égal à 15 (i.e. 4x4 -1 sachant qu'un thread reste réservé pour l'appelant)...

    Arrays.parallelSort() s'appuie sur ForkJoinPool.getCommonPoolParallelism() pour déterminer si la // doit être effective: bref sur dual core (et biensûr un single core) aucune chance d'avoir une quelconque // !

    Par défaut nous disposons d'un seul pool de thread fork-join : donc les performances vont être dépendantes du nombre de tâches à paralléliser.

    En se qui concerne l'API stream les résultats vont aussi être dépendants de la source de données (par exemple, à la différence d'un Array, une LinkedList se prêtera mal à la // - il en sera de même pour une source de flux I/O - etc). Attention aussi aux opérations longues lors d'une //... de telles opérations seront pénalisantes et le résultat risque fort d'être décevant. Au final Stream.parallel() est facile d'utilisation; mais les résultats sont souvent décevants

    a+
    Philippe

  3. #3
    Nouveau Candidat au Club
    Homme Profil pro
    Développeur Java
    Inscrit en
    octobre 2016
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : octobre 2016
    Messages : 1
    Points : 1
    Points
    1

    Par défaut

    Bonjour Philippe,

    Petite coquille dans la conclusion : Arrays.parallelSort utilise bien l'API fork-join ! et puis les Lambdas utilisent déjà invokeDynamic !
    Sur le fond, nous sommes d'accord. Ce qu'il fallait comprendre dans la conclusion :

    (...) l'apparition dans le JDK 8 du tri parallèle sans fork/join pool, par la méthode Arrays.parallelSort()
    En effet, fork/join est utilisé dans Arrays.parallelSort() ... Ce que je voulais dire par là, c'est que désormais l'écriture du fork/join n'est plus à la charge du développeur qui souhaite faire un tri parallélisé ; elle est encapsulée dans la méthode Arrays.parallelSort() du JDK8.

    Néanmoins, les expressions lambda étant encore bien jeunes dans le monde Java, on est en droit d'espérer des optimisations notables sur leur invocation, dans les prochaines versions de JVM (optimisations qui seront prises en compte dynamiquement, sur un bytecode Java déjà « lambda ready », grâce à l'utilisation d'invokeDynamic !).
    InvokeDynamic est effectivement déjà utilisé quand on écrit une lambda. Ce qu'il fallait comprendre ici, c'est que c'est grâce à cela que les futures optimisations de la JVM (sans changement sur le SDK) pourront voir le jour.

    Enfin, je suis d'accord sur le fait que même si les API facilitent grandement le travail de découpage et d’exécution d'un traitement en parallèle, elles ne nous dispensent pas de résoudre les problèmes classiques liés à la parallélisation (tels que les goulots d'étranglement)

  4. #4
    Membre expert
    Avatar de Pill_S
    Homme Profil pro
    Développeur Java
    Inscrit en
    janvier 2004
    Messages
    2 131
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Finance

    Informations forums :
    Inscription : janvier 2004
    Messages : 2 131
    Points : 3 288
    Points
    3 288

    Par défaut

    Après une première lecture, je me suis dit "tiens, mais en fait les différences sont vraiment minimes voir insignifiantes..."

    Ensuite, j'ai remarqué que l'échelle était logarithmique... Et ça, ça change tout

    Du coup, je me demande si ce serait pas mieux d'avoir une échelle normale (quitte à découper les graphiques en morceaux plus petits)? ça rendrait l'interprétation plus naturelle...
    "Si tu avoir un problème et choisir regexp comme solution, maintenant tu avoir 2 problèmes"

    Confucius, 448 av. J-C

Discussions similaires

  1. [Toutes versions] Tutoriel pour Drag and Drop entre deux formulaires Access
    Par yonnel dans le forum Contribuez
    Réponses: 11
    Dernier message: 19/08/2015, 21h34
  2. Réponses: 2
    Dernier message: 23/05/2014, 15h30
  3. Tutoriel pour apprendre à monitorer une machine virtuelle Java en local
    Par Mickael Baron dans le forum Général Java
    Réponses: 1
    Dernier message: 04/12/2013, 15h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo