Dans log4j, est-ce que le contrôle est désactivé avant la journalisation améliore les performances?

puisque dans l'option 1 la chaîne de messages est une constante, il n'y a absolument aucun gain à envelopper la déclaration de journalisation avec une condition, au contraire, si la déclaration de journalisation est activée, vous évaluerez deux fois, une fois dans la méthode isDebugEnabled() et une fois dans la méthode debug() . Le coût d'invoquer isDebugEnabled() est de l'ordre de 5 à 30 nanosecondes, ce qui devrait être négligeable pour la plupart des raisons pratiques. Par conséquent, l'option 2 n'est pas souhaitable parce qu'elle pollue votre code et ne procure aucun autre gain.

utilisant le isDebugEnabled() est réservé pour quand vous construisez des messages de log en concaténant des chaînes:

Var myVar = new MyVar();
log.debug("My var is " + myVar + ", value:" + myVar.someCall());

cependant, dans votre exemple, il n'y a pas de gain de vitesse car vous enregistrez juste une chaîne et n'effectuez pas des opérations telles que la concaténation. Par conséquent, vous ajoutez simplement bloat à votre code et le rendant plus difficile à lire.

j'utilise personnellement les appels au format Java 1.5 dans la classe String comme ceci:

Var myVar = new MyVar();
log.debug(String.format("My var is '%s', value: '%s'", myVar, myVar.someCall()));

je doute qu'il y ait beaucoup d'optimisation, mais c'est plus facile à lire.

notez cependant que la plupart des API de journalisation offrent un formatage comme celui-ci: slf4j par exemple fournit ce qui suit:

logger.debug("My var is {}", myVar);

qui est encore plus facile à lire.

version courte: vous pourriez aussi bien faire le booléen isDebugEnabled() check.

motifs:

1-si complexe logique / chaîne concat. est ajouté à votre déclaration de débogage que vous aurez déjà la vérification en place.

2 - vous n'avez pas à inclure sélectivement la déclaration sur les déclarations de débogage "complexes". Toutes les instructions sont incluses.

3 - l'Appel du journal.debug exécute ce qui suit avant exploitation forestière:

if(repository.isDisabled(Level.DEBUG_INT))

return;

c'est essentiellement la même chose que le journal d'appel. ou un chat. isDebugEnabled ().

cependant! C'est ce que les développeurs de log4j pensent (car c'est dans leur javadoc et vous devriez probablement y aller.)

C'est la méthode

public
  boolean isDebugEnabled() {
     if(repository.isDisabled( Level.DEBUG_INT))
      return false;
    return Level.DEBUG.isGreaterOrEqual(this.getEffectiveLevel());
  }

c'est le javadoc pour ça

/**
*  Check whether this category is enabled for the <code>DEBUG</code>
*  Level.
*
*  <p> This function is intended to lessen the computational cost of
*  disabled log debug statements.
*
*  <p> For some <code>cat</code> Category object, when you write,
*  <pre>
*      cat.debug("This is entry number: " + i );
*  </pre>
*
*  <p>You incur the cost constructing the message, concatenatiion in
*  this case, regardless of whether the message is logged or not.
*
*  <p>If you are worried about speed, then you should write
*  <pre>
*    if(cat.isDebugEnabled()) {
*      cat.debug("This is entry number: " + i );
*    }
*  </pre>
*
*  <p>This way you will not incur the cost of parameter
*  construction if debugging is disabled for <code>cat</code>. On
*  the other hand, if the <code>cat</code> is debug enabled, you
*  will incur the cost of evaluating whether the category is debug
*  enabled twice. Once in <code>isDebugEnabled</code> and once in
*  the <code>debug</code>.  This is an insignificant overhead
*  since evaluating a category takes about 1%% of the time it
*  takes to actually log.
*
*  @return boolean - <code>true</code> if this category is debug
*  enabled, <code>false</code> otherwise.
*   */

L'Option 2 est meilleure.

en soi, il n'améliore pas les performances. Mais cela garantit que la performance ne se dégrade pas. Voici comment.

Normalement nous attendons enregistreur.debug (someString);

mais habituellement, comme l'application se développe, change beaucoup de mains, les développeurs novices de l'esp, vous pourriez voir

logger.debug(ch1 + ch2 + str3 + str4);

et similaires.

même si le niveau de log est défini à erreur ou FATAL, la concaténation des chaînes se produit ! Si l'application contient beaucoup de messages de niveau de débogage avec des concaténations de chaîne, alors il prend certainement un coup de performance en particulier avec jdk 1.4 ou inférieur. (Je ne suis pas sûr que les versions ultérieures de JDK internall fassent un stringbuffer.annexer.))(

C'est pourquoi L'Option 2 est sûre. Même les enchaînements ne se produisent pas.

comme d'autres l'ont mentionné, l'utilisation de l'instruction guard n'est vraiment utile que si la création de la chaîne est un appel qui prend du temps. Des exemples spécifiques de cela sont lorsque la création de la chaîne de caractères déclenchera un chargement paresseux.

il est intéressant de noter que ce problème peut être évité en utilisant la façade de journalisation simple pour Java ou (SLF4J) - http://www.slf4j.org/manual.html . Cela permet des appels de méthode tels que:

logger.debug("Temperature set to {}. Old temperature was {}.", t, oldT);

cela ne convertira les paramètres passés en chaînes que si le débogage est activé. SLF4J comme son nom l'indique n'est qu'une façade et les appels de journalisation peuvent être passés à log4j.

vous pourriez aussi très facilement" rouler votre propre " version de ceci.

Espérons que cette aide.

en Java 8, Vous n'avez pas à utiliser isDebugEnabled() pour améliorer les performances.

https://logging.apache.org/log4j/2.0/manual/api.html#Java_8_lambda_support_for_lazy_logging

import java.util.logging.Logger;
...
Logger.getLogger("hello").info(() -> "Hello " + name);

comme @erickson cela dépend. Si je me souviens, isDebugEnabled est déjà construit dans la méthode debug() de Log4j.

Tant que vous ne faites pas de calculs coûteux dans vos déclarations de débogage, comme loop on objects, effectuer des calculs et concatenate strings, vous êtes très bien à mon avis.

StringBuilder buffer = new StringBuilder();
for(Object o : myHugeCollection){
  buffer.append(o.getName()).append(":");
  buffer.append(o.getResultFromExpensiveComputation()).append(",");
}
log.debug(buffer.toString());

serait mieux que

if (log.isDebugEnabled(){
  StringBuilder buffer = new StringBuilder();
  for(Object o : myHugeCollection){
    buffer.append(o.getName()).append(":");
    buffer.append(o.getResultFromExpensiveComputation()).append(",");
  }
  log.debug(buffer.toString());
}

il améliore la vitesse parce qu'il est commun de concaténer des chaînes dans le texte de débogage qui est cher par exemple:

boolean debugEnabled = logger.isDebugEnabled();
if (debugEnabled) {
    logger.debug("some debug text" + someState);
}

For a single line , j'utilise un ternaire à l'intérieur du message de journalisation, de cette façon je ne fais pas la concaténation:

ej:

logger.debug(str1 + str2 + str3 + str4);

je n':

logger.debug(logger.isDebugEnable()?str1 + str2 + str3 + str4:null);

mais pour lignes multiples du code

ej.

for(Message mess:list) {
    logger.debug("mess:" + mess.getText());
}

je ne:

if(logger.isDebugEnable()) {
    for(Message mess:list) {
         logger.debug("mess:" + mess.getText());
    }
}

comme beaucoup de gens regardent probablement cette réponse en cherchant log4j2 et que presque toutes les réponses actuelles ne tiennent pas compte de log4j2 ou de changements récents, cela devrait répondre à la question.

log4j2 supporte Supplier s (actuellement leur propre implémentation, mais selon la documentation il est prévu d'utiliser L'interface fournisseur de Java dans la version 3.0). Vous pouvez lire un peu plus à ce sujet dans le manuel . Cela vous permet de mettre la création de message de log coûteux dans un fournisseur qui ne crée le message si elle doit être journalisée:

LogManager.getLogger().debug(() -> createExpensiveLogMessage());

Si vous utilisez l'option 2 vous faites un Boolean qui est rapide. Dans la première option, vous faites un appel de méthode (poussant des trucs sur la pile) et ensuite faire un contrôle booléen qui est encore rapide. Le problème que je vois est la cohérence. Si certaines de vos instructions de débogage et d'information sont emballées et que d'autres ne le sont pas, ce n'est pas un style de code cohérent. Plus quelqu'un plus tard pourrait changer la déclaration de débogage pour inclure des chaînes concaténées, ce qui est encore assez rapide. J'ai trouvé ça quand nous avons terminé debug. et info déclaration dans une grande application et profilé il nous a sauvé quelques points de pourcentage dans la performance. Pas beaucoup, mais assez pour le rendre intéressant le travail. J'ai maintenant quelques macros configurées dans IntelliJ pour générer automatiquement des instructions de débogage et d'information pour moi.

au 2.x, Apache Log4j a cette vérification intégrée, donc avoir isDebugEnabled() n'est plus nécessaire. Il suffit de faire un debug() et les messages seront supprimés s'ils ne sont pas activés.

Log4j2 vous permet de formater des paramètres dans un modèle de message, similaire à String.format() , éliminant ainsi la nécessité de faire isDebugEnabled() .

Logger log = LogManager.getFormatterLogger(getClass());
log.debug("Some message [myField=%s]", myField);

échantillon simple log4j2.propriétés:

filter.threshold.type = ThresholdFilter
filter.threshold.level = debug
appender.console.type = Console
appender.console.name = STDOUT
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %d %-5p: %c - %m%n
appender.console.filter.threshold.type = ThresholdFilter
appender.console.filter.threshold.level = debug
rootLogger.level = info
rootLogger.appenderRef.stdout.ref = STDOUT

je recommande d'utiliser L'Option 2 comme de facto pour la plupart car elle n'est pas super chère.

Case 1: journal.debug("une chaîne")

Case2: journal.debug("une chaîne" + "deux cordes" + objet.toString + object2.toString)

au moment où l'un ou l'autre s'appelle, la chaîne de paramètres dans log.le débogage (QU'il s'agisse du cas 1 ou du cas 2) doit être évalué. C'est ce que tout le monde veut dire par " cher."Si vous avez une condition avant il, " isDebugEnabled ()", ceux-ci n'ont pas à être évalués qui est où la performance est sauvegardée.