La plupart des développeurs tiennent pour acquis que l'optimisation des performances est complexe et nécessite beaucoup d'expérience et de connaissances. Eh bien, on ne peut pas dire que c'est complètement faux. L'optimisation de votre application pour des performances optimales n'est pas une tâche facile. Cependant, cela ne signifie pas que vous ne pouvez rien faire si vous n'avez pas cette connaissance. Voici 11 conseils et meilleures pratiques faciles à suivre pour vous aider à créer une application performante.
La plupart des suggestions concernent Java. Mais il existe plusieurs suggestions indépendantes du langage et peuvent être appliquées à toutes les applications et aux langages de programmation. Avant de discuter des techniques de réglage des performances spécifiquement pour Java, jetons un œil aux conseils généraux.
1. N'optimisez pas tant que vous ne savez pas que c'est nécessaire
C'est probablement l'un des conseils de réglage des performances les plus importants. Vous devez suivre les meilleures pratiques communes et essayer de mettre en œuvre efficacement vos cas d'utilisation. Cependant, cela ne signifie pas que vous devez remplacer toute bibliothèque standard ou créer des optimisations complexes avant de prouver nécessaire.
Dans la plupart des cas, l'optimisation prématurée prendra non seulement beaucoup de temps, mais rendra également le code difficile à lire et à maintenir. Pire, ces optimisations n'apportent généralement aucun avantage, car ce que vous passez beaucoup de temps à optimiser, c'est la partie non critique de l'application.
Alors, comment prouvez-vous que vous devez optimiser quelque chose?
Tout d'abord, vous devez définir la vitesse à laquelle votre code d'application est, par exemple, en spécifiant un temps de réponse maximal pour tous les appels d'API, ou en spécifiant le nombre d'enregistrements à importer dans une plage de temps spécifique. Une fois que vous avez fait cela, vous pouvez mesurer les parties de l'application trop lentes à améliorer. Ensuite, regardons le deuxième tour.
2. Utilisez l'analyseur pour trouver le vrai goulot d'étranglement
Après avoir suivi la première suggestion et déterminé que certaines parties de l'application doivent être améliorées, alors par où commencer?
Vous pouvez résoudre le problème de deux manières:
Consultez votre code et commencez par la pièce qui semble suspecte ou que vous pensez que vous pouvez être problématique.
Ou utilisez l'analyseur et obtenez des informations détaillées sur le comportement et les performances de chaque partie du code.
J'espère que je n'ai pas besoin d'expliquer pourquoi je devrais toujours suivre la deuxième méthode.
Il est évident qu'une approche basée sur l'analyse vous permet de mieux comprendre l'impact des performances de votre code et vous permettra de vous concentrer sur les parties les plus critiques. Si vous avez utilisé un analyseur, vous devez vous rappeler à quel point vous étiez surpris pour découvrir quelles parties du code avaient des problèmes de performances. Pour être honnête, ma première supposition m'a conduit à la mauvaise direction plus d'une fois.
3. Créez une suite de tests de performances pour l'ensemble de l'application
Il s'agit d'une autre astuce universelle qui peut vous aider à éviter de nombreux problèmes inattendus qui se produisent souvent après le déploiement d'améliorations des performances à la production. Vous devez toujours définir une suite de tests de performance qui teste l'ensemble de l'application et l'exécuter avant et après les améliorations des performances.
Ces essais supplémentaires vous aideront à identifier les effets secondaires fonctionnels et de performances des modifications et de vous assurer qu'aucun mal que de bonnes mises à jour n'est causé. Ceci est particulièrement important si vous travaillez sur des composants utilisés par plusieurs parties différentes de l'application, telles que des bases de données ou des caches.
4. Transformez d'abord le plus grand goulot d'étranglement
Après avoir créé une suite de test et analysé l'application à l'aide de l'analyseur, vous pouvez répertorier une gamme de problèmes qui doivent être résolus pour améliorer les performances. C'est génial, mais cela ne répond toujours pas à la question de savoir où vous devez commencer. Vous pouvez vous concentrer sur des solutions à action rapide ou commencer par les questions les plus importantes.
Les schémas d'action rapide peuvent être attrayants au début car vous pouvez rapidement montrer le premier résultat. Mais parfois, vous devrez peut-être convaincre les autres membres de l'équipe ou la direction que l'analyse des performances en vaut la peine - car il n'y a aucun effet pour le moment.
Mais dans l'ensemble, je recommande d'abord de traiter les problèmes de performances les plus importants. Cela vous fournira les plus grandes améliorations des performances et ne peut plus résoudre certains de ces problèmes pour répondre aux exigences de performance.
Les conseils de réglage des performances communs se terminent ici. Examinons de plus près quelques conseils spécifiques à Java.
5. Utilisez StringBuilder pour connecter la chaîne programmatiquement
Il existe de nombreuses options différentes pour connecter les chaînes en Java. Par exemple, vous pouvez utiliser Simple + ou + =, ainsi que StringBuffer ou StringBuilder.
Alors, quelle méthode devez-vous choisir?
La réponse dépend du code reliant la chaîne. Si vous ajoutez un nouveau contenu à une chaîne par programme, par exemple dans une boucle pour une boucle, vous devez utiliser StringBuilder. Il est facile à utiliser et offre de meilleures performances que StringBuffer. Mais n'oubliez pas que par rapport à StringBuffer, StringBuilder n'est pas en filetage et peut ne pas convenir à tous les cas d'utilisation.
Vous avez juste besoin d'instancier un nouveau StringBuilder et d'appeler la méthode APPEND pour ajouter une nouvelle pièce à la chaîne. Après avoir ajouté toutes les pièces, vous pouvez appeler la méthode toString () pour récupérer la chaîne connectée.
L'extrait de code suivant montre un exemple simple. Au cours de chaque itération, cette boucle se convertit en une chaîne et l'ajoute à StringBuilder SB avec un espace. Ainsi, à la fin, ce code écrira "Ceci est un test0 1 2 3 4 5 6 7 8 9" dans le fichier journal.
StringBuilder sb = new StringBuilder ("Ceci est un test"); pour (int i = 0; i <10; i ++) {sb.append (i); sb.append ("");} log.info (sb.toString ());Comme vous pouvez le voir dans l'extrait de code, vous pouvez fournir le premier élément de la chaîne au constructeur. Cela créera un nouveau StringBuilder qui contient la chaîne fournie et la capacité de 16 caractères supplémentaires. Lorsque vous ajoutez plus de caractères au StringBuilder, le JVM augmentera dynamiquement la taille du StringBuilder.
Si vous savez déjà combien de caractères contiendra votre chaîne, vous pouvez fournir ce numéro à différents constructeurs pour instancier un STRACHBUILDER avec une capacité définie. Cela améliore encore l'efficacité car il ne nécessite pas une expansion dynamique de sa capacité.
6. Utiliser + pour concaténer la chaîne dans une instruction
Lorsque vous implémentez votre première application dans Java, quelqu'un peut vous avoir dit que vous ne devriez pas utiliser + pour vous connecter à la chaîne. Si vous concaténez les chaînes dans la logique d'application, c'est correct. Les chaînes sont immuables et les résultats de la concaténation de chaque chaîne sont stockés dans un nouvel objet de chaîne. Cela nécessite une mémoire supplémentaire et ralentira votre application, surtout si vous concaténez plusieurs chaînes dans une boucle.
Dans ces cas, vous devez suivre la pointe 5 et utiliser StringBuilder.
Mais si vous avez simplement divisé la chaîne en plusieurs lignes pour améliorer la lisibilité de votre code, c'est différent.
Query q = em.Createequery ("SELECT A.ID, A.FirstName, A.LastName"
+ «De l'auteur A»
+ «Où a.id =: id»);
Dans ces cas, vous devez utiliser un + simple pour concaténer votre chaîne. Le compilateur Java optimise cela et effectue des connexions au moment de la compilation. Ainsi, au moment de l'exécution, votre code n'utilisera que 1 chaîne et aucune connexion n'est requise.
7. Utilisez autant que possible les primitives
Un autre moyen facile et rapide d'éviter les frais généraux et d'améliorer les performances de l'application consiste à utiliser le type de base au lieu de sa classe de wrapper. Par conséquent, il est préférable d'utiliser INT au lieu d'entier et de double au lieu de double. Cela permet au JVM de stocker des valeurs sur la pile plutôt que le tas pour réduire la consommation de mémoire et effectuer un traitement plus efficace.
8. Essayez d'éviter BigInteger et Bigdecimal
Étant donné que nous discutons des types de données, examinons rapidement BigInteger et BigDecimal. En particulier, ce dernier est populaire pour sa précision. Mais il y a un prix.
BigInteger et BigDecimal nécessitent plus de mémoire que simple longue ou double et ralentiront considérablement tous les calculs. Donc, si vous avez besoin d'une précision supplémentaire ou si les chiffres dépasseront la longue portée, il est préférable de réfléchir à deux fois avant de le faire. C'est probablement la seule façon de changer pour résoudre les problèmes de performances, en particulier lors de la mise en œuvre d'algorithmes mathématiques.
9. Vérifiez d'abord le niveau de journal actuel
Cette suggestion devrait être évidente, mais malheureusement, de nombreux programmeurs l'ignorent principalement lors de l'écriture de code. Avant de créer un message de débogage, vous devez toujours vérifier d'abord le niveau de journal actuel. Sinon, vous pourriez créer une chaîne de message de journal qui sera ignorée plus tard.
Voici deux exemples négatifs.
// Ne faites pas thisLog.debug ("utilisateur [" + nom d'utilisateur + "] appelé méthode x avec [" + i + "]"); // ou thislog.debug (string.format ("user [% s] appelé méthode x avec [% d]", nom d'utilisateur, i));Dans les deux cas, vous effecturez toutes les étapes nécessaires pour créer un message de journal sans savoir si le cadre du journal utilisera le message du journal. Par conséquent, il est préférable de vérifier le niveau de journal actuel avant de créer un message de débogage.
// faire thisIf (log.isdebugeNabled ()) {log.debug ("utilisateur [" + nom d'utilisateur + "] appelé méthode x avec [" + i + "]");}10. Utilisez Apache Commons StringUtils.replace au lieu de String.replace
D'une manière générale, la méthode String.replace fonctionne bien et est très efficace, surtout lorsque vous utilisez Java 9. Cependant, si votre application nécessite beaucoup d'opérations de remplacement et n'est pas mise à jour vers la dernière version Java, il est toujours nécessaire de trouver des alternatives plus rapides et plus efficaces.
Il existe une autre réponse à la méthode d'Apache Commons Lang StringUtils.replace. Comme Lukas Eder l'a décrit dans un récent article de blog, la méthode StringUtils.replace est bien supérieure à la méthode String.re.replace de Java 8.
Et cela ne nécessite que des changements mineurs. Autrement dit, ajoutez les dépendances Maven du projet Apache Commons Lang à l'application pom.xml et remplacez tous les appels par la méthode string.replace par la méthode stringUtils.replace.
// Remplacez ThisTest.replace ("Test", "Test simple"); // par thisStringUtils.replace (test, "test", "test simple");11. Cache Ressources coûteuses, telles que les connexions de base de données
La mise en cache est une solution populaire pour éviter l'exécution répétée des extraits de code coûteux ou communs. L'idée générale est simple: il est moins cher de réutiliser ces ressources que de créer à plusieurs reprises de nouvelles ressources.
Un exemple typique est une connexion de base de données dans un pool de cache. Les nouvelles connexions prennent du temps à créer, ce qui peut être évité si vous réutilisez les connexions existantes.
Vous pouvez également trouver d'autres exemples dans la langue java elle-même. Par exemple, la valeur de la méthode de la classe entière cache des valeurs entre -128 et 127. Vous pourriez dire que la création d'un nouvel entier n'est pas trop coûteuse, mais parce qu'elle est souvent utilisée, la mise en cache des valeurs les plus couramment utilisées peut également fournir des avantages de performance.
Cependant, lorsque vous envisagez la mise en cache, n'oubliez pas que les implémentations de cache peuvent également entraîner des frais généraux. Vous devez dépenser une mémoire supplémentaire pour stocker des ressources réutilisables, vous devrez donc peut-être gérer les caches pour rendre les ressources accessibles, ainsi que supprimer des ressources obsolètes.
Donc, avant de commencer à mettre en cache des ressources, assurez-vous que la mise en œuvre du cache en vaut la peine, c'est-à-dire que vous devez les utiliser suffisamment.
Résumer
Comme vous pouvez le voir, il ne faut parfois pas beaucoup de travail pour améliorer les performances de votre application. La plupart des suggestions de cet article nécessitent juste un peu d'effort pour les appliquer à votre code.
Mais la chose la plus importante est les astuces qui ne sont pas liées à quel langage de programmation il s'agit:
N'optimisez pas d'utiliser des analyseurs pour trouver de vrais goulots d'étranglement avant de savoir que c'est nécessaire. Traitez d'abord les plus grands goulots d'étranglement.
Ce qui précède est tout le contenu partagé dans cet article sur les techniques de réglage des performances Java très simples et faciles à comprendre. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à ce site:
Java implémente le code détaillé pour le partage des fonctions de la plate-forme publique WeChat Moments WeChat
Analyse comparative des instances de performance de la sérialisation native de Java et de la sérialisation Kryo
Exploration sur la question de savoir si la sous-classe de programmation Java peut réécrire la méthode statique de la classe parentale
S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!