L’architecture JVM et son fonctionnement ?

Maintenant, sautons dans chaque partie.

1.Sous-système du chargeur de classe :

La fonctionnalité de chargement dynamique des classes Java est gérée par le sous-système du chargeur de classe. « Load -> Link -> Initialiser le fichier de classe » pour la première fois au moment de l’exécution.

1.1. Chargement : Les classes seront chargées par ce composant.

1. Bootstrap Class Loader – charge la classe à partir du chemin de la classe bootstrap (rt.jar -high priority)
2. Extension Class Loader – charge la classe qui est incluse dans (jre/lib).
3. Application Class Loader – charge la classe de niveau application.

1.2 Linking : Effectue la vérification, la préparation et la résolution sur la classe chargée.

1. Vérification : Le vérificateur de bytecode vérifiera si le bytecode généré est correct ou non, sinon nous obtiendrons une erreur de vérification(java.lang.VerifyError)
2. Préparation : Pour toutes les variables statiques du bytecode , la mémoire sera allouée et les valeurs par défaut seront chargées.
3. Resolve(Optional) : Les références symboliques de la classe seront remplacées par les références originales de la zone des méthodes.

1.3 Initialisation : Phase finale du chargeur de classe , ici toutes les variables statiques se verront attribuer des valeurs originales & bloc statique s’exécute.

2. Zone de données d’exécution : (mémoire JVM) – divisée en 5 composants

1. Zone de méthode : elle stockera toutes les données de niveau classe (champs, méthode,variable statique). Une seule zone de méthode par JVM.
2. Zone Heap : tous les objets & correspondant instance , variable , tableau seront stockés. Un Heap par JVM

• où Heap & Method Area ne sont pas thread safe it shared resource for JVM

3. Stack Area : Pour chaque thread new stack at runtime will be created. Pour chaque appel de méthode , une entrée sera ajoutée dans la pile appelée stack frame.

1. La variable locale sera stockée dans la mémoire de la pile
2. Thread safe
3. Stack Frame est divisé en trois sous entités :

3.1 Local Variable Array : lié à la méthode locale , les variables sont invloved

3.2 Operand Stack : Opération intermédiaire – agit comme espace de travail d’exécution pour effectuer l’opération

3.3 Frame Data : tous les symboles correspondant à la méthode seront stockés , en cas d’exception , les informations du catch block seront maintenues.

4. PC Registers : Chaque Thread aura un registre qui stocke l’opération en cours d’exécution.(une fois chaque instruction mise à jour , le registre PC mettra également à jour l’instruction suivante)

5. Pile de méthodes natives : Détient les informations de méthode native pour chaque thread.

3. Moteur d’exécution : Le code octet qui est assigné dans la zone de données d’exécution sera exécuté.

1. Interprète : Interprète le bytecode plus rapidement mais l’exécution est lente.(une méthode est appelée plusieurs fois, il créera une nouvelle Interprétation est nécessaire).
2. Compilateur JIT : neutraliser l’inconvénient de l’interprète.Chaque fois qu’il trouve le code répété, il utilise le compilateur JIT.

Il compilera le bytecode en code natif (le code natif sera utilisé directement pour les appels de méthode répétés).

Générateur de code intermédiaire : génère du code intermédiaire chaque fois que cela est nécessaire

Optimiseur de code : Optimise le code

Générateur de code cible : Convertit en code machine / natif

Profileur : Aide à trouver les appels multiples de méthodes (finding hotspots)

.