Comment réussir un entretien Java : questions et réponses avancées

Comment réussir un entretien Java : les questions avancées les plus courantes

Un entretien pour un poste de Senior Java Developer ne se limite pas à une simple vérification de la syntaxe. Les recruteurs veulent s'assurer que vous comprenez le fonctionnement interne de la JVM, que vous savez concevoir des systèmes multithreadés et que vous maîtrisez les subtilités du garbage collection. Dans cet article, nous analysons les questions les plus fréquentes et les plus complexes pour vous aider à réussir votre entretien technique.

1. Multithreading et modèle mémoire Java (JMM)

C'est l'un des sujets les plus vastes. Les recruteurs vérifient si vous comprenez comment les threads interagissent via la mémoire partagée et quels problèmes peuvent survenir.

Question : Quelle est la différence entre volatile et synchronized ?

Réponse : volatile garantit la visibilité des modifications pour tous les threads, mais n'assure pas l'atomicité. synchronized garantit à la fois la visibilité et l'atomicité (en verrouillant le moniteur).

// Exemple d'utilisation de volatile\npublic class VolatileExample {\n    private volatile boolean running = true;\n\n    public void stop() {\n        running = false; // La modification est immédiatement visible par les autres threads\n    }\n\n    public void run() {\n        while (running) {\n            // exécution du travail\n        }\n    }\n}

Question : Qu'est-ce que la relation happens-before dans JMM ?

Réponse : C'est une relation d'ordre partiel qui garantit que les actions d'un thread seront visibles par un autre. Par exemple, l'écriture dans une variable volatile crée une relation happens-before avec la lecture ultérieure de cette variable par un autre thread. Une relation happens-before se produit également lors de l'entrée/sortie d'un bloc synchronized.

Question : Comment fonctionne ConcurrentHashMap ?

Réponse : En Java 8+, ConcurrentHashMap utilise un segmentation au niveau des buckets. Au lieu de verrouiller toute la table, seul le bucket concerné est verrouillé (en cas de collision). Pour les opérations de lecture, aucun verrou n'est utilisé — une lecture volatile est employée. En cas de forte concurrence, les structures internes peuvent être réorganisées (par exemple, un arbre remplace une liste).

// Exemple ConcurrentHashMap\nConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();\nmap.put("key", 1);\nInteger value = map.get("key"); // Lecture sans verrou

2. Garbage collection et optimisation du GC

Les questions sur le Garbage Collector (GC) sont obligatoires pour les postes Senior. Vous devez connaître non seulement les types de GC, mais aussi comment les configurer en fonction de la charge.

Question : Quels sont les principaux types de GC dans la JVM HotSpot ?

Réponse : Les principaux collecteurs :

\n
• Serial GC — monothreadé, pour les applications client.
\n
• Parallel GC (Throughput) — multithreadé, orienté débit.
\n
• G1 GC (Garbage First) — par défaut depuis Java 9, divise le tas en régions, minimise les pauses.
\n
• ZGC et Shenandoah — collecteurs à faible latence avec des pauses inférieures à 10 ms.
\n

Question : Qu'est-ce qu'une pause Stop-The-World ?

Réponse : C'est le moment où tous les threads de l'application sont suspendus pour permettre au GC d'effectuer son travail. Les pauses STW longues sont critiques pour les systèmes temps réel. G1 GC essaie de les minimiser en effectuant la collecte en parallèle et de manière incrémentale.

Question : Comment détecter une fuite mémoire en Java ?

Réponse : Utilisez des profileurs (VisualVM, JProfiler). Surveillez la croissance du heap dump. Les causes typiques de fuites : collections statiques non libérées, implémentation incorrecte de equals/hashCode dans HashMap, écouteurs qui ne se désabonnent pas.

// Exemple de fuite : collection statique\npublic class LeakExample {\n    private static List<byte[]> cache = new ArrayList<>();\n\n    public void addData() {\n        cache.add(new