Passer aux informations sur le produit
Comment bien lire Java
Comment bien lire Java
Description
Introduction au livre
Techniques de profilage, de débogage et de journalisation pour identifier les bogues et les problèmes de performance Java.

En pratique, les développeurs passent la majeure partie de leur temps à lire et à comprendre le code existant.
Ce livre présente des techniques pratiques qui permettront de réduire le temps nécessaire à la compréhension d'un code Java inconnu.
En effectuant des profils et des débogages, et en comprenant finalement comment vos applications JVM fonctionnent réellement, vous pouvez trouver les causes profondes des dépendances ou des plantages et interpréter les résultats inattendus.
Des bases du débogage aux méthodes avancées de détection des problèmes dans les architectures de microservices, ce livre vous apprend à « lire » le code Java grâce à des illustrations informelles et des exemples concrets et attrayants.
  • Vous pouvez consulter un aperçu du contenu du livre.
    Aperçu

indice
Préface du traducteur x
Avis du lecteur bêta xi
Début xiv
Remerciements xvi
À propos de ce livre xviii
À propos de la couverture xxi

PARTIE I : Techniques de dépannage de base

CHAPITRE 1 Clarification des parties ambiguës de l'application 3
1.1 Comment mieux comprendre l'application 4
1.2 Scénarios courants d'enquête sur le code 8
__1.2.1 Identifier la cause d'une sortie inattendue 9
1.2.2 Acquérir des compétences spécifiques 14
1.2.3 Déterminez pourquoi la vitesse diminue.
__1.2.4 Comprendre pourquoi les applications plantent 16
1.3 Ce que vous apprendrez dans ce livre 19
Résumé 20

CHAPITRE 2 Comprendre la logique des applications grâce aux techniques de débogage 21
2.1 Quand l'analyse de code seule est insuffisante 23
2.2 Examen du code à l'aide d'un débogueur 26
__2.2.1 Qu'est-ce qu'une trace de pile d'exécution et comment dois-je l'utiliser ? 31
__2.2.2 Navigation dans le code avec le débogueur 36
2.3 Si le débogueur ne suffit pas, essayez 43
Résumé 45

CHAPITRE 3 Trouver la cause première des problèmes grâce à des techniques de débogage avancées 47
3.1 Minimisation du temps d'investigation grâce aux points d'arrêt conditionnels 48
3.2 Comment utiliser les points d'arrêt sans interrompre l'exécution 52
3.3 Modification dynamique du scénario d'enquête 55
3.4 Retour sur l'enquête, dossier 58
Résumé 64

CHAPITRE 4 : Débogage des applications distantes 65
4.1 Qu'est-ce que le débogage à distance ? 66
4.2 Enquêter dans un environnement isolé 69
__4.2.1 Scénario 70
4.2.2 Investigation des problèmes en environnement distant 71
Résumé 81

CHAPITRE 5 Surveillance du comportement des applications à l'aide des journaux 83
5.1 Enquête à l'aide des journaux 87
5.1.1 Identification des exceptions enregistrées dans les journaux 88
__5.1.2 Identification de l'emplacement d'appel d'une méthode avec une trace de pile d'exceptions 89
__5.1.3 Mesure du temps d'exécution des commandes dans une architecture multithread 91
5.1.4 Analyse des problèmes d'exécution des commandes dans les architectures multithread 92
5.2 Comment implémenter la journalisation 94
__5.2.1 Enregistrement des messages de journalisation 94
5.2.2 Comment définir les niveaux de journalisation et utiliser le framework de journalisation 95
5.2.3 Problèmes et précautions liés à l'exploitation forestière 102
5.3 Journaux et débogage à distance 107
Résumé 108

PARTIE II Techniques de dépannage avancées

CHAPITRE 6 Identification des problèmes d'utilisation des ressources grâce aux techniques de profilage 111
6.1 Quand un profileur est-il utile ? 112
6.1.1 Identification d'une utilisation anormale des ressources 112
6.1.2 Recherche du code en cours d'exécution 113
6.1.3 Identification de la cause de la lenteur du lancement de l'application 114
6.2 Comment utiliser le Profiler 114
6.2.1 Installation et configuration de VisualVM 115
6.2.2 Observation de l'utilisation du processeur et de la mémoire 117
6.2.3 Identification des fuites de mémoire 127
Résumé 132

CHAPITRE 7 : Détection des problèmes cachés grâce aux techniques de profilage 133
7.1 Observation du code exécuté avec l'échantillonnage 134
7.2 Détermination du nombre d'exécutions d'une méthode par profilage 142
7.3 Utilisation du profileur pour déterminer les requêtes SQL réellement exécutées par votre application 144
7.3.1 Identification des requêtes SQL non générées par le framework avec le Profiler 144
__7.3.2 Identification des requêtes SQL générées par le framework à l'aide d'un profileur 150
7.3.3 Identification des requêtes SQL générées par des programmes avec un profileur 153
Résumé 157

CHAPITRE 8 Application d'outils de visualisation avancés aux données profilées 159
8.1 Détection des problèmes de connexion JDBC 160
8.2 Comprendre la conception du code de l'application en examinant le graphe d'appels 173
8.3 Création de graphiques en flammes pour identifier les problèmes de performance 175
8.4 Analyse des requêtes dans les bases de données NoSQL 179
Résumé 180

CHAPITRE 9 Étude des problèmes de verrouillage dans les architectures multithread 183
9.1 Surveillance du blocage de filetage 184
9.2 Analyse du frein-filet 189
9.3 Analyse des threads en attente 198
Résumé 205

CHAPITRE 10 : Investigation des problèmes de blocage à l’aide des vidages de threads 207
10.1 Collecte des vidages de threads 208
__10.1.1 Collecte des vidages de threads avec Profiler 210
__10.1.2 Collecte des vidages de threads depuis la ligne de commande 212
10.2 Comment lire un vidage de thread 215
__10.2.1 Vidage de thread en texte brut 216
__10.2.2 Lecture des vidages de threads à l'aide d'outils 222
Résumé 225

CHAPITRE 11 Détection des problèmes de mémoire lors de l'exécution d'une application 227
11.1 Diagnostic des problèmes de mémoire par échantillonnage et profilage 228
11.2 Collecte des vidages de tas pour détecter les fuites de mémoire 235
__11.2.1 Collecte des vidages de tas 236
__11.2.2 Comment lire un vidage de tas 240
__11.2.3 Requête de vidage de tas dans la console OQL 245
Résumé 251

PARTIE III DÉPANNAGE DES SYSTÈMES À GRANDE ÉCHELLE

CHAPITRE 12 : Analyse du comportement des applications déployées sur des systèmes à grande échelle 255
12.1 Enquête sur les problèmes de communication interservices 256
__12.1.1 Observation des requêtes HTTP avec la sonde de serveur HTTP 257
__12.1.2 Observation des requêtes HTTP envoyées par votre application avec la sonde client HTTP 259
__12.1.3 Analyse des événements de bas niveau des sockets 261
12.2 L'importance de la surveillance intégrée des journaux 263
12.3 Comment utiliser les outils de diffusion pour la recherche 270
__12.3.1 Simulation de problèmes difficiles à reproduire par injection de fautes 272
__12.3.2 Utilisation des techniques de mise en miroir pour les tests et la détection d'erreurs 273
Résumé 274

ANNEXE A Outils utilisés dans ce livre 275

ANNEXE B Ouverture d'un projet 277

ANNEXE C Autres références 279

ANNEXE D Comprendre les threads Java 281

D.1 Qu'est-ce qu'un fil de discussion ? 282
D.2 Cycle de vie du fil 284
D.3 Synchronisation des threads 286
__D.3.1 Bloc de synchronisation 286
__D.3.2 Utilisation de wait(), notify() et notifyAll() 289
__D.3.3 Jointure de fil 290
__D.3.4 Blocage d'un thread pendant une période de temps fixe 291
__D.3.5 Synchronisation des threads et blocage des objets 292
D.4 Problèmes courants liés aux architectures multithread 293
__D.4.1 Conditions de course 293
__D.4.2 Impasse 294
__D.4.3 Ribrak 295
__D.4.4 Kia ​​​​296
D.5 Matériel supplémentaire 297

ANNEXE E Cadre de gestion de la mémoire Java 299
E.1 Comment la JVM organise la mémoire de votre application 300
E.2 Pile 302 utilisée par les threads pour stocker des données locales
E.3 Mémoire Heap 308 utilisée par l'application pour stocker les instances d'objets
E.4 Emplacements mémoire Metaspace pour le stockage des types de données 311

Recherche 313

Image détaillée
Image détaillée 1

Dans le livre
Un débogueur est un logiciel qui aide les développeurs à lire et à comprendre plus facilement le code source en exécutant ce code étape par étape tout en interrompant brièvement l'exécution aux commandes souhaitées.
Bien que les débogueurs soient un moyen courant d'étudier le comportement des logiciels (et souvent la première chose que les développeurs apprennent), ils ne sont pas la seule technique de débogage, ni utiles dans tous les scénarios (l'utilisation de base des débogueurs et les techniques avancées sont abordées dans les chapitres 2 et 3).
Les différentes techniques de recherche que vous apprendrez tout au long de ce livre sont illustrées dans la figure 1.3.

--- P.6

Comme pour toute technique d'enquête, il y a des moments où l'utilisation des journaux de bord est appropriée et d'autres où elle ne l'est pas.
Dans cette section, nous explorerons plusieurs scénarios où l'utilisation des journaux peut faciliter la compréhension du comportement de votre application.
Nous aborderons d'abord quelques points clés concernant les messages de journalisation, puis nous verrons comment ces caractéristiques peuvent aider les développeurs à analyser les problèmes de leurs applications.

--- P.87

La chose la plus simple que vous puissiez faire avec un profileur est d'observer comment votre application utilise les ressources système.
Rien qu'en l'examinant de cette façon, vous pouvez découvrir des problèmes tels que des fuites de mémoire ou des threads zombies dans votre application.
En analysant une application en cours d'exécution à l'aide d'un profileur, vous pouvez facilement détecter les comportements anormaux de l'application.
Par exemple, les threads zombies qui restent actifs et occupent les ressources de l'application même après la fin de son exécution sont immédiatement exposés dans VisualVM.
Voyons maintenant comment VisualVM peut être utilisé pour détecter et observer les signes d'une consommation anormale de ressources dans une application.

--- P.117

Configurez le pilote JDBC pour intercepter les requêtes que l'application envoie à la base de données.
Suite à la vérification (Figure 7.14), la table des produits effectue une auto-jointure avec elle-même.
C'est un problème sérieux ! Cet exemple peut paraître anodin, car la table ne contient que 10 enregistrements, mais dans une application réelle, elle en contiendrait probablement un très grand nombre. Un tel croisement de données entraînerait inévitablement une latence importante et, au final, des résultats incorrects (lignes dupliquées).
En interceptant la requête avec VisualVM et en l'analysant, vous pouvez immédiatement identifier l'origine du problème.

--- P.154

Dans VisualVM, sélectionnez l'onglet Sampler, puis cliquez sur le bouton Memory pour démarrer une session d'échantillonnage de l'utilisation de la mémoire.
Après avoir appelé le point de terminaison et attendu la fin de l'opération, vous verrez apparaître les objets alloués par votre application sur l'écran VisualVM après un court instant.
(…) Je comprends qu’un grand nombre d’instances peuvent saturer la mémoire, mais est-il possible qu’un petit nombre d’instances volumineuses, comme celle mentionnée précédemment, puissent occuper la majeure partie de la mémoire ? Prenons l’exemple d’une application qui traite des fichiers vidéo volumineux.
Chargez 2 à 3 fichiers à la fois, mais les fichiers vidéo sont tellement volumineux qu'ils peuvent saturer la mémoire.
Dans ces cas-là, il est judicieux d'étudier si l'application peut être optimisée en ne chargeant pas l'intégralité du fichier en mémoire d'un seul coup, mais plutôt en ne chargeant que des portions à la fois.

--- P.231

Cette application étant développée sur la base de Spring Boot, la valeur DSN est spécifiée dans l'attribut sentry.dsn du fichier application.properties, comme illustré dans l'extrait de code suivant.
Ceci est facultatif dans Sentry, mais il est recommandé de spécifier l'environnement dans lequel votre application s'exécute si possible.
En effet, vous pourrez ensuite filtrer les événements pour n'extraire que ceux qui vous intéressent.
--- P.267

Avis de l'éditeur
Conseils pour comprendre, déboguer et optimiser le code JVM afin d'améliorer sa lisibilité.

Au fur et à mesure de votre progression de carrière, vous constaterez que vous passez beaucoup plus de temps à lire du code qu'à en écrire.
Ce livre présente des techniques d'analyse de code permettant d'utiliser efficacement ce temps précieux.
L'un de ses principaux avantages est qu'il explique le dépannage de manière conviviale pour les développeurs et orientée scénarios, depuis les bases du débogage et de la journalisation jusqu'aux techniques de profilage avancées et au fonctionnement des applications JVM.


La première partie aborde les bases des techniques d'investigation pour comprendre un code source.
Les chapitres 2 à 4 sont consacrés au débogage, des simples points d'arrêt au débogage à distance, tandis que le chapitre 5 examine comment utiliser les journaux pour analyser les détails essentiels liés à l'implémentation du code.


La deuxième partie démontre à quel point le profilage peut être utile dans l'environnement de développement actuel, fortement axé sur les frameworks.
Le chapitre 6 explique comment analyser l'utilisation du processeur et de la mémoire à l'aide d'outils de profilage tels que VisualVM et JProfiler, et le chapitre 7 explique comment étudier les problèmes de latence.
Les chapitres 8 et 9 approfondissent l'architecture multithread, le chapitre 10 examine les vidages de threads et le chapitre 11 explique comment diagnostiquer les problèmes de mémoire en générant des vidages de tas.


La partie 3, chapitre 12, explique comment étudier les problèmes dans les grands systèmes d'entreprise composés de plusieurs applications, plutôt que d'une seule application.
Nous examinerons comment chaque application « communique » avec les autres, l'impact de l'environnement dans lequel l'application est déployée et les considérations relatives à la mise en œuvre.
Enfin, l'annexe fournit une explication détaillée du système de gestion des threads et de la mémoire de Java, qui sera d'une aide précieuse pour les développeurs Java.


Comprendre le fonctionnement réel des applications JVM peut vous aider à identifier la cause première des problèmes.
Il s'agit d'un ouvrage rare qui couvre de manière exhaustive non seulement le débogage et la journalisation, mais aussi les techniques avancées de détection des problèmes dans les architectures de microservices.


Contenu principal
• Comprenez ce que fait le code que vous voyez pour la première fois.
• Mise en évidence des problèmes de logique du code
• Détecter les fuites de mémoire en évaluant les vidages de tas
• Surveillez l'utilisation du processeur pour optimiser l'exécution.
Détection et résolution des interblocages à l'aide de dumps de threads
Comprendre les systèmes orientés services/microservices
• Utilisez correctement la journalisation pour comprendre en profondeur l'exécution des applications Java.
• Utiliser efficacement le débogueur Java
SPÉCIFICATIONS DES PRODUITS
- Date d'émission : 9 mai 2024
- Nombre de pages, poids, dimensions : 340 pages | 188 × 245 × 17 mm
- ISBN13 : 9791193926208
- ISBN10 : 1193926203

Vous aimerez peut-être aussi

카테고리