Formations — 1 037 leçons en français

Accueil › Java › Architecture de la JVM

Architecture de la JVM

La JVM et la mémoireavance

Un programme Java suit trois étapes : javac compile le code source en bytecode (fichiers .class), la JVM charge ces classes à la demande, puis les exécute — d'abord interprétées instruction par instruction, puis compilées à la volée (JIT) pour les méthodes fréquemment exécutées (voir le chapitre Performance pour le détail du JIT).

Le chargement des classes suit une hiérarchie à trois niveaux avec délégation parent-first : le chargeur bootstrap (natif, charge java.base), le chargeur platform (modules standard du JDK hors java.base) et le chargeur application (le classpath ou module-path de l'application). Chaque chargeur demande d'abord à son parent avant d'essayer lui-même — ce qui empêche une classe applicative de usurper une classe du JDK.

public class Demo {
    public static void main(String[] args) {
        System.out.println(String.class.getClassLoader()); // null : chargée par le bootstrap
        System.out.println(Demo.class.getClassLoader());   // chargeur application
    }
}

Une classe est chargée paresseusement, à sa première référence réelle — mais chargement et initialisation (exécution des blocs static et des initialiseurs de champs statiques) sont deux étapes distinctes : une classe peut être chargée sans être encore initialisée.

Deux erreurs à distinguer en entretien : ClassNotFoundException (chargement explicite raté, ex. Class.forName) et NoClassDefFoundError (une classe présente à la compilation devient introuvable à l'exécution).

Les termes à connaître

Fichier .class

Résultat de la compilation par javac : bytecode indépendant de la plateforme, précédé du nombre magique 0xCAFEBABE, suivi des numéros de version, d'un pool de constantes, des indicateurs d'accès, des références de classe/superclasse/interfaces, puis des champs, méthodes (avec leur bytecode) et attributs.

Chargeur bootstrap

Le premier chargeur, écrit en code natif (pas en Java) et intégré à la JVM. Il charge les classes fondamentales du JDK (java.lang.*, java.util.*…) depuis le module java.base. getClassLoader() sur une classe qu'il a chargée renvoie null.

Délégation parent-first

Modèle de chargement où un chargeur de classes délègue d'abord la demande à son parent avant d'essayer lui-même. Une classe n'est donc chargée par un chargeur enfant que si aucun de ses ancêtres ne l'a trouvée — ce qui empêche une application de redéfinir accidentellement java.lang.String.

Chargement paresseux (lazy loading)

Une classe n'est chargée par la JVM que lorsqu'elle est réellement référencée pour la première fois, pas au démarrage du programme ni à la compilation. Chargement (lecture du .class, création de l'objet Class) et initialisation (exécution des blocs static et des initialiseurs de champs statiques) sont deux étapes distinctes.

ClassNotFoundException vs NoClassDefFoundError

ClassNotFoundException (checked) est levée quand un chargement explicite échoue (Class.forName("..."), loadClass(...)) parce que la classe est introuvable. NoClassDefFoundError (unchecked, sous-classe d'Error) est levée quand la JVM ne trouve pas, au runtime, une classe qui existait pourtant à la compilation — typiquement un .jar manquant en exécution, ou l'échec d'un précédent chargement de la même classe (par exemple un bloc static qui a levé une exception).

Chargeur de classes personnalisé

Sous-classe de ClassLoader qui redéfinit findClass() pour charger du bytecode depuis une source non standard (réseau, base de données, plugin chiffré). Utilisé pour des architectures à plugins, l'isolation de versions concurrentes d'une même bibliothèque, ou le rechargement à chaud (hot reload).

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.