Accueil › Spring Boot › En production
En production — entretien Spring Boot
3 questions posées en entretien sur 3 sujets, avec la bonne réponse et son explication.
Virtual threads
Un service annoté avec un bloc `synchronized` effectue un appel HTTP bloquant à l'intérieur de ce bloc, sur un thread virtuel. Quel est le risque principal sous forte charge ?
public synchronized void traiter(Commande c) {
reponseExterne = clientHttp.appeler(c); // bloquant
}
- Aucun risque : les threads virtuels ignorent totalement `synchronized`
- Le thread virtuel reste épinglé (pinné) à son carrier pendant tout l'appel bloquant, empêchant ce carrier de servir d'autres threads virtuels et réduisant la concurrence effective ✓
- Une `ConcurrentModificationException` est levée systématiquement
- Le thread virtuel est détruit automatiquement par la JVM et l'appel échoue
Pourquoi : `synchronized` provoque un épinglage : contrairement à un blocage d'E/S normal (où le thread virtuel est démonté), ici il reste attaché à son carrier. Sous forte charge, avec beaucoup de threads virtuels épinglés simultanément, le nombre de carriers disponibles (proche du nombre de cœurs) redevient le facteur limitant — exactement le problème que les virtual threads étaient censés résoudre. La solution : remplacer `synchronized` par un `ReentrantLock` dans le code chaud, ou déplacer l'appel bloquant hors du bloc synchronisé.
Niveau senior
Images natives
Pourquoi un code qui fonctionne parfaitement sur une JVM classique peut-il échouer à l'exécution une fois compilé en image native ?
- Parce que les images natives n'exécutent pas correctement les boucles et les conditions
- Parce que GraalVM applique une hypothèse de monde fermé : tout accès par réflexion, proxy ou ressource non déclaré au moment du build risque d'être absent du binaire final ✓
- Parce que les images natives ne supportent pas Spring Boot au-delà de la version 2
- Parce que les images natives n'acceptent aucun DTO Java, seulement des types primitifs
Pourquoi : GraalVM détermine au moment du build tout ce qui doit être conservé dans le binaire. Le traitement AOT de Spring couvre automatiquement une grande partie des usages internes du framework, mais un usage manuel de réflexion (désérialisation directe, bibliothèque tierce non compatible) peut nécessiter un `RuntimeHints` explicite ou `@RegisterReflectionForBinding` pour ne pas échouer au runtime, parfois seulement visible en testant réellement le binaire natif.
Niveau confirme
Performance et tuning
Une application souffre de lenteurs sous charge. Quelle est la première étape recommandée avant de modifier un paramètre comme la taille du pool HikariCP ?
- Doubler immédiatement `maximum-pool-size`, c'est rarement risqué
- Mesurer où se situe réellement le goulot d'étranglement (métriques, requêtes lentes, état du pool de connexions) avant tout changement ✓
- Passer directement `spring.jpa.open-in-view` à `false` sans vérifier son impact
- Activer l'initialisation paresseuse, qui améliore systématiquement les performances en production
Pourquoi : Modifier un paramètre sans mesure de référence revient à changer un réglage au hasard : impossible de savoir ensuite si l'effet observé vient du changement ou d'une variation naturelle de charge. Un pool de connexions trop grand peut même dégrader le débit par contention côté base de données — d'où l'importance de mesurer avant d'agir, puis de valider le changement avec un test de charge reproductible.
Niveau confirme