Les tableaux typés aident-ils le JIT à optimiser son fonctionnement?

Question

Ma question est la suivante:

Son habitude pour le code Java pour avoir des collections génériques mis en œuvre comme:

public class GenericCollection<T> { 
    private Object[] data; 

    public GenericCollection() { 
     // Backing array is a plain object array. 
     this.data = new Object[10]; 
    } 

    @SuppressWarnings("unchecked") 
    public T get(int index) { 
     // And we just cast to appropriate type when needed. 
     return (T) this.data[index]; 
    } 
} 

Et utilisé comme celui-ci par exemple:

for (MyObject obj : genericCollection) { 
    obj.myObjectMethod(); 
} 

Comme le type générique de genericCollection est effacé, la JVM ne semble pas avoir un moyen de savoir que vraiment dans le tableau 'data' de genericCollection il n'y a que des instances MyObject, puisque le type réel du tableau est Object, il peut y avoir un String, et appeler 'myObjectMethod' dessus soulèverait une exception.

Donc, je suppose que la JVM doit faire de la gymnastique de vérification de l'exécution pour savoir ce qu'il y a vraiment dans cette instance de GenericCollection.

Regardez maintenant cette implémentation:

public class GenericCollection<T> { 
    private T[] data; 

    @SuppressWarnings("unchecked") 
    public GenericCollection (Class<T> type) { 
     // Create a type specific array. 
     this.data = (T[]) Array.newInstance(type, 10); 
    } 

    public T get (int index) { 
     // No unsafe casts needed. 
     return this.data[index]; 
    } 
} 

Dans ce cas, nous créons un type matrice spécifique par la réflexion, de sorte que la machine virtuelle Java pourrait en déduire qu'il pourrait y avoir être seulement des objets T se trouvant dans ce tableau dans un contexte donné, ce qui les moulages dangereux et les chèques de type coûteux éventuels redondants. Ma question serait, étant donné les possibilités offertes par HotSpot, de mettre en œuvre, de quelque façon que ce soit, des implémentations de génériques avec une matrice de sauvegarde spécifique de type «appropriée»?

Par exemple, aide-t-il HotSpot à supprimer les vérifications de type ou les conversions inutiles? Peut-être peut-être l'activer pour des méthodes en ligne plus facilement étant donné qu'il sait que le tableau de support est d'un type spécifique?

Answer 1

Pas dans ce cas particulier.

Le tableau générique T[] est effacé à Object[] dans le bytecode. Le getter de tableau pour Object[] renvoie toujours Object, il n'a donc pas besoin de vérifier le type de tableau réel. Par conséquent, il n'y a aucun avantage à avoir T[] au lieu de Object[] pour l'opération d'obtention de tableau. Dans les deux cas, il y a aaload instruction suivie de checkcast, et cela fonctionne de la même manière.

Pendant ce temps setter tableau fonctionnera pire pour le tableau typé plutôt que Object[], car aastore doit vérifier que la valeur correspond au type de composant de tableau réel.

C'est, votre modification proposée fonctionne également pour get, mais effectue pire pour set. Cela peut être confirmé par le benchmark JMH suivant.

package bench; 

import org.openjdk.jmh.annotations.*; 

import java.lang.reflect.Array; 

@State(Scope.Benchmark) 
public class Generics { 
    private ObjectArray<String> objectArray; 
    private GenericArray<String> genericArray; 
    private StringArray stringArray; 
    private int index; 

    @Param("100000") 
    private int length; 

    @Setup 
    public void setup() { 
     genericArray = new GenericArray<>(String.class, length); 
     objectArray = new ObjectArray<>(length); 
     stringArray = new StringArray(length); 

     for (int i = 0; i < length; i++) { 
      String s = Integer.toString(i); 
      objectArray.set(i, s); 
      genericArray.set(i, s); 
      stringArray.set(i, s); 
     } 
    } 

    @Benchmark 
    public String getGenericArray() { 
     return genericArray.get(nextIndex()); 
    } 

    @Benchmark 
    public String getObjectArray() { 
     return objectArray.get(nextIndex()); 
    } 

    @Benchmark 
    public String getStringArray() { 
     return stringArray.get(nextIndex()); 
    } 

    @Benchmark 
    public void setGenericArray() { 
     genericArray.set(nextIndex(), "value"); 
    } 

    @Benchmark 
    public void setObjectArray() { 
     objectArray.set(nextIndex(), "value"); 
    } 

    @Benchmark 
    public void setStringArray() { 
     stringArray.set(nextIndex(), "value"); 
    } 

    private int nextIndex() { 
     if (++index == length) index = 0; 
     return index; 
    } 

    static class GenericArray<T> { 
     private T[] data; 

     @SuppressWarnings("unchecked") 
     public GenericArray(Class<T> type, int length) { 
      this.data = (T[]) Array.newInstance(type, length); 
     } 

     public T get(int index) { 
      return data[index]; 
     } 

     public void set(int index, T value) { 
      data[index] = value; 
     } 
    } 

    static class ObjectArray<T> { 
     private Object[] data; 

     public ObjectArray(int length) { 
      this.data = new Object[length]; 
     } 

     @SuppressWarnings("unchecked") 
     public T get(int index) { 
      return (T) data[index]; 
     } 

     public void set(int index, T value) { 
      data[index] = value; 
     } 
    } 

    static class StringArray { 
     private String[] data; 

     public StringArray(int length) { 
      this.data = new String[length]; 
     } 

     public String get(int index) { 
      return data[index]; 
     } 

     public void set(int index, String value) { 
      data[index] = value; 
     } 
    } 
} 

Et les résultats:

hotspot

Benchmark     (length) Mode Cnt Score Error Units 
Generics.getGenericArray 100000 avgt 40 5,212 ± 0,038 ns/op <- equal 
Generics.getObjectArray  100000 avgt 40 5,224 ± 0,043 ns/op <- 
Generics.getStringArray  100000 avgt 40 4,557 ± 0,051 ns/op 
Generics.setGenericArray 100000 avgt 40 3,299 ± 0,032 ns/op <- worse 
Generics.setObjectArray  100000 avgt 40 2,456 ± 0,007 ns/op <- 
Generics.setStringArray  100000 avgt 40 2,138 ± 0,008 ns/op 

Answer 2

Non, le tutoriel Java type erasure explique

ont été introduites

Génériques au langage Java pour fournir des contrôles plus stricts de type à la compilation et pour soutenir la programmation générique. Pour implémenter les génériques, le compilateur Java applique l'effacement de type à:

• Remplacer tous les paramètres de type dans les types génériques par leurs bornes ou Object si les paramètres de type sont non bornés. Le bytecode produit contient donc uniquement des classes, des interfaces et des méthodes ordinaires.
• Insérer des moulages de type si nécessaire pour préserver la sécurité du type.
• Génère des méthodes de pont pour préserver le polymorphisme dans les types génériques étendus.

Ainsi, après la compilation, les types génériques sont Object.