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

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

Un entretien pour un poste de développeur Java de niveau avancé (Middle/Senior) ne se limite pas à une simple vérification de la syntaxe. Les recruteurs veulent voir une compréhension approfondie du fonctionnement interne de la JVM, du multithreading, des algorithmes du ramasse-miettes et des subtilités de la bibliothèque standard. Dans cet article, nous analysons les questions les plus fréquentes et les plus complexes qui vous aideront à réussir votre entretien technique en toute confiance.

1. Multithreading et synchronisation : de volatile à Lock

Un entretien Java avancé commence presque toujours par des questions sur le multithreading. Vous devez non seulement connaître le mot-clé synchronized, mais aussi comprendre comment fonctionnent volatile, AtomicInteger, ReentrantLock et ce qu'est le principe happens-before.

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

La différence clé est la flexibilité. synchronized est un verrou au niveau du moniteur de l'objet. ReentrantLock offre des fonctionnalités avancées : la possibilité d'interrompre l'attente d'un thread (lockInterruptibly()), une tentative d'acquisition sans blocage (tryLock()), ainsi que la prise en charge de plusieurs conditions (Condition).

// Exemple d'utilisation de ReentrantLock avec Conditionimport java.util.concurrent.locks.ReentrantLock;import java.util.concurrent.locks.Condition;

public class BlockingQueueExample {    private final ReentrantLock lock = new ReentrantLock();    private final Condition notFull = lock.newCondition();    private final Condition notEmpty = lock.newCondition();    private final Object[] items = new Object[10];    private int putIndex, takeIndex, count;

    public void put(Object x) throws InterruptedException {        lock.lock();        try {            while (count == items.length) {                notFull.await(); // attend que de l'espace se libère            }            items[putIndex] = x;            if (++putIndex == items.length) putIndex = 0;            count++;            notEmpty.signal(); // signale qu'un élément est apparu        } finally {            lock.unlock();        }    }

    public Object take() throws InterruptedException {        lock.lock();        try {            while (count == 0) {                notEmpty.await(); // attend qu'un élément apparaisse            }            Object x = items[takeIndex];            if (++takeIndex == items.length) takeIndex = 0;            count--;            notFull.signal(); // signale que de l'espace s'est libéré            return x;        } finally {            lock.unlock();        }    }}

Question : Comment fonctionne le mot-clé volatile ?

volatile garantit que la lecture et l'écriture d'une variable se font directement depuis la mémoire principale (main memory), en contournant le cache du processeur. Cela assure la visibilité des modifications pour tous les threads, mais ne garantit pas l'atomicité (par exemple, l'incrémentation count++ nécessite toujours une synchronisation).

Il faut également se souvenir du principe happens-before : l'écriture dans une variable volatile se produit avant toute lecture ultérieure de cette même variable depuis un autre thread.

2. Java Memory Model (JMM) et Garbage Collector

Comprendre comment la JVM gère la mémoire est une exigence obligatoire pour un développeur Senior. Les recruteurs posent souvent des questions sur les différentes générations (Young/Old Generation), les types de ramasse-miettes et la configuration de la JVM.

Question : Quels types de Garbage Collector existent dans Java 17 ?

Java moderne (17+) prend en charge plusieurs GC :

• G1GC (Garbage First) — GC par défaut. Il divise le tas en régions et collecte les déchets dans les régions contenant le plus d'objets morts.
• ZGC (Z Garbage