MethodHandle – De quoi s’agit-il?

J’étudie les nouvelles fonctionnalités de JDK 1.7 et je n’arrive pas à comprendre pourquoi MethodHandle est conçu? Je comprends l’invocation (directe) de la méthode statique (et l’utilisation de l’API Core Reflection qui est simple dans ce cas). Je comprends également l’appel (direct) de la méthode virtuelle (non statique, non final) (et l’utilisation de l’API Core Reflection qui nécessite de passer par la hiérarchie de Class obj.getClass().getSuperclass() ). L’invocation d’une méthode non virtuelle peut être traitée comme un cas particulier de la méthode précédente.

Oui, je sais qu’il y a un problème de surcharge. Si vous souhaitez appeler la méthode, vous devez fournir la signature exacte. Vous ne pouvez pas rechercher facilement la méthode surchargée.

Mais qu’est-ce que MethodHandle? L’API de reflection vous permet de “regarder” l’object interne de l’object sans présupposition (comme implémenté l’interface). Vous pouvez inspecter l’object pour quelque but. Mais qu’est-ce que MethodHandle est conçu aussi? Pourquoi et quand devrais-je l’utiliser?

MISE À JOUR: Je lis maintenant cet article http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html . Selon lui, l’objective principal est de simplifier la vie des langages de script qui s’exécutent au sumt de JVM, et non pour le langage Java lui-même.

UPDATE-2: Je termine pour lire le lien ci-dessus, une citation de là:

La machine virtuelle Java sera la meilleure machine virtuelle pour la création de langages dynamics, car elle est déjà une VM de langage dynamic. Et InvokeDynamic, en faisant la promotion de langages dynamics auprès des citoyens de première classe de la JVM, le prouvera.

Utiliser la reflection pour invoquer des méthodes fonctionne très bien … sauf pour quelques problèmes. Les objects méthode doivent être extraits d’un type spécifique et ne peuvent pas être créés de manière générale.

… l’invocation réfléchie est beaucoup plus lente que l’invocation directe. Au fil des ans, la JVM est devenue très efficace pour lancer rapidement des appels réfléchis. Les machines virtuelles Java modernes génèrent en réalité un tas de code en arrière-plan pour éviter une grande partie des anciennes JVM traitées. Mais la simple vérité est que l’access réfléchi par un nombre quelconque de couches sera toujours plus lent qu’un appel direct, en partie parce que la méthode “invoke” complètement généralisée doit vérifier et vérifier le type de récepteur, les types d’arguments, la visibilité et d’autres détails. aussi parce que les arguments doivent tous être des objects (les primitives sont donc placées dans un object) et doivent être fournis sous forme de tableau pour couvrir toutes les arités possibles (les arguments sont donc encadrés).

La différence de performances peut ne pas avoir d’importance pour une bibliothèque effectuant quelques appels réfléchis, surtout si ces appels sont principalement destinés à configurer dynamicment une structure statique en mémoire avec laquelle elle peut effectuer des appels normaux. Mais dans un langage dynamic, où chaque appel doit utiliser ces mécanismes, il s’agit d’un problème de performance grave.

http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html

Donc, pour le programmeur Java, il est essentiellement inutile. Ai-je raison? De ce sharepoint vue, il ne peut être considéré que comme une alternative pour l’API Core Reflection.

Il est le précurseur de Java 8 et prend en charge le langage pour MethodHandles. Vous pourrez vous référer directement à une méthode et MethodHandles le supportera.

Ce que vous pouvez faire avec MethodHandles, ce sont des méthodes de curry, modifiez les types de parameters et modifiez leur ordre.

Method Handles peut gérer à la fois les méthodes et les champs.

Une autre astuce que MethodHandles fait est d’utiliser des primitives directes (plutôt que via des wrappers)

MethodHandles peut être plus rapide que d’utiliser la reflection car il existe un support plus direct dans la JVM, par exemple, ils peuvent être intégrés. Il utilise la nouvelle instruction invokedynamic.

java.lang.reflect.Method est relativement lent et coûteux en termes de mémoire. Les descripteurs de méthode sont supposés être un moyen “léger” de faire passer des pointeurs à des fonctions que la JVM a une chance d’optimiser. Au fur et à mesure des JDK8, les descripteurs de méthode ne sont pas bien optimisés, et les lambdas sont probablement implémentés initialement en termes de classes (car les classes internes le sont).

Pensez à MethodHandle comme un moyen moderne, plus flexible et plus sûr de faire de la reflection.

Il en est actuellement aux premiers stades de son cycle de vie – mais avec le temps, il est possible de l’optimiser pour devenir plus vite nécessaire que la reflection – au point qu’il peut devenir aussi rapide qu’un appel de méthode régulier.