Parlons du projet Java Valhalla

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement l'introduction du projet Java Valhalla et une introduction détaillée autour du thème. Examinons-le ensemble, j'espère qu'il sera utile à tout le monde.

Étude recommandée : "Tutoriel vidéo Java"

Dans cet article, nous présenterons le projet Valhalla - ses raisons historiques, son état de développement actuel et ce qu'il a apporté aux développeurs Java quotidiens après sa sortie Quoi.

Motivation et raisons du projet Valhalla

L'architecte du langage Java d'Oracle, Brian Goetz, a déclaré dans un discours que l'une des principales motivations du projet Valhalla est le désir d'adapter le langage et le runtime Java au matériel moderne. Lorsque le langage Java est né (au moment de la rédaction de cet article il y a environ 25 ans), l'accès à la mémoire et les opérations arithmétiques coûtaient à peu près le même prix.

Aujourd'hui, cette situation a changé, les opérations de récupération de mémoire sont 200 à 1000 fois plus coûteuses que les opérations arithmétiques. En termes de conception du langage, cela signifie que les opérations indirectes entraînant des extractions de pointeurs peuvent nuire aux performances globales.

Étant donné que la plupart des structures de données Java dans une application sont des objets, nous pouvons considérer Java comme un langage à forte intensité de pointeurs (même si nous ne les voyons ou ne les manipulons généralement pas directement). Cette implémentation d'objet basée sur un pointeur est utilisée pour permettre l'identification d'objet, qui elle-même est utilisée pour les fonctionnalités du langage telles que le polymorphisme, la mutabilité et le verrouillage. Par défaut, ces propriétés s'appliquent à chaque objet, qu'elles soient réellement nécessaires ou non.

Suite à la chaîne d'identités menant aux pointeurs et à la chaîne de pointeurs menant à l'indirection, l'indirection présente un inconvénient de performances et la conclusion logique est de supprimer les structures de données qui n'en ont pas besoin. C’est là que les types valeur entrent en jeu.

Types de valeur Le concept de types de valeur

est de représenter une pure agrégation de données. Cela supprime les fonctionnalités des objets normaux. Nous avons donc des données pures, pas d'identité. Bien entendu, cela signifie que nous perdons également la fonctionnalité qui peut être obtenue grâce à l'identification d'objets. Par conséquent, les comparaisons d’égalité ne peuvent être effectuées que sur la base du statut. Par conséquent, nous ne pouvons pas utiliser le polymorphisme de représentation, ni utiliser d’objets immuables ou non nullables.

Puisque nous n'avons plus d'identité d'objet, nous pouvons abandonner les pointeurs et modifier la disposition générale de la mémoire des types valeur au lieu des objets. Comparons la disposition de la mémoire entre les points de classe et les points de type valeur correspondants.

Le code et la disposition de mémoire correspondante pour la classe Point normale seraient :

final class Point {
  final int x;
  final int y;
}

D'autre part, le code et la disposition de mémoire correspondante pour le type de valeur Point seraient :

value class Point {
  int x;
  int y
}

Cela permet aux types de valeurs JVM Flatten de se transformer en tableaux et objets, ainsi que d'autres types de valeurs.

Dans l'image ci-dessous, nous montrons les effets négatifs indirects lors de l'utilisation de la classe Point dans un tableau :

Par contre, nous voyons ici la correspondance du type de valeur Point[] Structure de la mémoire : <code>Point[]的相应内存结构：

它还使JVM能够在栈上传递值类型，而不必在堆上分配它们。最后，这意味着我们得到的数据聚合具有类似于Java原语的运行时行为，如int或float。

但与原语不同，值类型可以有方法和字段。我们还可以实现接口并将其用作泛型类型。

因此，我们可以从两个不同的角度来看值类型：

• 更快的对象
• 用户定义原语

作为额外的锦上添花，我们可以使用值类型作为泛型类型，而无需装箱。这直接将我们引向了另一个大型项目Valhalla的特性：专用泛型。

Specialized Generics 专用泛型

当我们想对语言原语进行泛化时，我们目前使用装箱类型，例如整数表示Integer或浮点表示Float。这种装箱创建了一个额外的间接层，从而首先破坏了使用原语提高性能的目的。

因此，我们在现有的框架和库中看到了许多针对基元类型的专门化，如IntStream＜T＞或ToIntFunction＜T＞。这样做是为了保持使用原语的性能提高。

因此，专门化泛型是为了消除这些“黑客”的需求。相反，Java语言努力为基本上所有东西启用泛型类型：对象引用、原语、值类型，甚至可能是void

🎜🎜 Il permet également la JVM pour transmettre les types de valeurs sur la pile sans avoir à les allouer sur le tas. En fin de compte, cela signifie que nous obtenons des agrégations de données avec un comportement d'exécution similaire aux primitives Java comme int ou float. 🎜🎜Mais contrairement aux primitives, les types valeur peuvent avoir des méthodes et des champs. Nous pouvons également implémenter des interfaces et les utiliser comme types génériques. 🎜🎜🎜Nous pouvons donc examiner les types de valeurs sous deux angles différents : 🎜🎜

• Objets plus rapides
• Primitives définies par l'utilisateur

🎜 Comme cerise sur le gâteau le gâteau, nous pouvons utiliser des types valeur comme types génériques sans 🎜boxing🎜. Cela nous amène directement à une autre fonctionnalité du grand projet Valhalla : les génériques spécialisés. 🎜🎜Génériques spécialisés 🎜🎜Lorsque nous voulons généraliser les primitives du langage, nous utilisons actuellement des types encadrés, tels que la représentation entière Integer ou la représentation à virgule flottante Float. Ce boxing crée une couche supplémentaire d'indirection, allant ainsi à l'encontre de l'objectif premier de l'utilisation de primitives pour améliorer les performances. 🎜🎜Ainsi, nous voyons de nombreuses spécialisations pour les types primitifs dans les frameworks et bibliothèques existants, tels que IntStream＜T＞ ou ToIntFunction＜T>. Ceci est fait pour maintenir les améliorations de performances liées à l'utilisation de primitives. 🎜🎜La spécialisation des génériques, c'est donc éliminer le besoin de ces "hacks". Au lieu de cela, le langage Java s'efforce d'activer des types génériques pour pratiquement tout : les références d'objet, les primitives, les types valeur et peut-être même void. 🎜

Conclusion

Nous avons une compréhension préliminaire des changements que le projet Valhalla apportera au langage Java. Deux des principaux objectifs sont d’améliorer les performances et de réduire les fuites d’abstractions.

Les améliorations des performances sont apportées en aplatissant le graphique des objets et en supprimant l'indirection. Cela se traduit par une disposition de la mémoire plus efficace et moins d'allocations et de garbage collection.

Lorsqu'ils sont utilisés comme type générique, les primitives et les objets ont un comportement plus similaire, ce qui constitue une meilleure abstraction.

Apprentissage recommandé : "Tutoriel vidéo Java"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!