在 log4j 中，在记录之前检查 isDebugEnabled 是否会提高性能？

Question

我在应用程序中使用 Log4J 进行日志记录。 以前我使用的是调试调用，例如：

选项 1：

logger.debug("some debug text");

，但一些链接建议最好先检查 isDebugEnabled()，例如：

选项 2：

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

我的问题是“选项 2 是否可以提高性能？”。

因为在任何情况下 Log4J 框架都会对 debugEnabled 进行相同的检查。 对于选项 2，如果我们在单个方法或类中使用多个调试语句，框架不需要多次调用 isDebugEnabled() 方法（每次调用时），这可能会很有用； 这种情况下，它仅调用 isDebugEnabled() 方法一次，如果 Log4J 配置为调试级别，那么实际上它会调用 isDebugEnabled() 方法两次：

1. 在 debugEnabled 变量，
2. 实际上由 logger.debug() 方法调用。

我不认为如果我们在方法或类中编写多个 logger.debug() 语句并根据选项 1 调用 debug() 方法，那么这对 Log4J 来说不是开销与选项 2 相比。由于 isDebugEnabled() 是一个非常小的方法（就代码而言），因此它可能是内联的良好候选者。

Answer 1

对于单行，我在日志消息中使用三元，这样我就不会进行连接：

ej：

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

我做：

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

但是对于多行代码

ej.

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

我愿意：

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

Answer 2

如果您使用选项 2，您将进行布尔检查，速度很快。 在选项一中，您正在执行方法调用（将内容推入堆栈），然后执行布尔检查，这仍然很快。 我看到的问题是一致性。 如果您的一些调试和信息语句被包装，而另一些则没有，那么这不是一致的代码风格。 另外，稍后有人可以更改调试语句以包含连接字符串，这仍然相当快。 我发现，当我们在大型应用程序中封装调试和信息语句并对其进行分析时，我们节省了几个百分点的性能。 不多，但足以让它值得工作。 我现在在 IntelliJ 中设置了几个宏，可以自动为我生成包装的调试和信息语句。

Answer 3

由于许多人在搜索 log4j2 时可能会查看此答案，并且几乎所有当前答案都不考虑 log4j2 或其中最近的更改，因此这应该有望回答该问题。

log4j2 支持 供应商< /a>s（目前是他们自己的实现，但根据文档，计划在 3.0 版本中使用 Java 的供应商接口）。 您可以在手册中阅读更多相关信息。 这允许您将昂贵的日志消息创建放入供应商中，该供应商仅在要记录消息时才创建消息：

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

Answer 4

Log4j2 允许您将参数格式化为消息模板，类似于 String.format() ，从而无需执行 isDebugEnabled() 。

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

简单 log4j2.properties 示例：

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

Answer 5

从 Log4j 版本 2.4 （或slf4j-api 2.0.0-alpha1）开始，最好使用 Fluent API （或 Java 8 lambda 支持延迟日志记录)，支持 Supplier 作为日志消息参数，可以通过 给出lambda：

log.debug("Debug message with expensive data : {}", 
           () -> doExpensiveCalculation());

或与 slf4j API：

log.atDebug()
            .addArgument(() -> doExpensiveCalculation())
            .log("Debug message with expensive data : {}");

Answer 6

我建议大多数人事实上使用选项 2，因为它并不是非常昂贵。

情况1：
log.debug("一个字符串")

案例2：
log.debug("one string" + "two string" + object.toString + object2.toString)

在调用其中任何一个时，必须评估 log.debug 中的参数字符串（无论是 CASE 1 还是 Case2） 。 这就是每个人所说的“昂贵”的意思。 如果前面有一个条件“isDebugEnabled()”，则不必评估这些条件，这就是保存性能的地方。

Answer 7

从 2.x 开始，Apache Log4j 内置了此检查，因此不再需要 isDebugEnabled() 。 只需执行 debug()，如果未启用，消息将被抑制。

Answer 8

在这种特殊情况下，选项 1 更好。

当涉及调用各种对象的 toString() 方法并连接结果。

在给定的示例中，日志消息是一个常量字符串，因此让记录器丢弃它与检查记录器是否启用一样有效，并且由于分支较少，因此降低了代码的复杂性。

更好的是使用更新的日志框架，其中日志语句采用格式规范和要由记录器替换的参数列表，但只有在启用记录器时才“惰性”。 这是 slf4j。

有关详细信息，请参阅我对相关问题的回答，以及使用 log4j 执行类似操作的示例。

Answer 9

由于在选项 1 中，消息字符串是常量，因此用条件包装日志语句绝对没有任何好处，相反，如果日志语句启用了调试，则您将评估两次，一次在 isDebugEnabled 中() 方法和一次 debug() 方法。 调用 isDebugEnabled() 的成本约为 5 到 30 纳秒，对于大多数实际用途来说，这应该可以忽略不计。 因此，选项 2 并不可取，因为它会污染您的代码并且不会提供其他好处。

Answer 10

使用 isDebugEnabled() 是在您通过连接字符串构建日志消息时保留的：

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

但是，在您的示例中，没有速度增益，因为您只是记录字符串而不执行诸如此类的操作作为串联。 因此，您只是在代码中添加了臃肿的内容，并使其更难以阅读。

我个人在 String 类中使用 Java 1.5 格式调用，如下所示：

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

我怀疑有很多优化，但它更容易阅读。

请注意，大多数日志记录 API 都提供如下开箱即用的格式：例如 slf4j 提供以下内容：

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

这甚至更易于阅读。

Answer 11

在 Java 8 中，您不必使用 isDebugEnabled() 来提高性能。

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);

Answer 12

正如其他人提到的，只有当创建字符串是一个耗时的调用时，使用保护语句才真正有用。 具体的例子是创建字符串时会触发一些延迟加载。

值得注意的是，可以通过使用 Simple Logging Facade for Java 或 (SLF4J) - http: //www.slf4j.org/manual.html 。 这允许方法调用，例如：

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

如果启用了调试，则仅将传入的参数转换为字符串。 SLF4J 顾名思义只是一个外观，日志记录调用可以传递给 log4j。

您也可以非常轻松地“推出您自己的”版本。

希望这可以帮助。

Answer 13

简短版本：您也可以执行布尔 isDebugEnabled() 检查。

原因：
1-如果复杂的逻辑/字符串连接。 添加到您的调试语句中，您将已经进行了检查。
2-您不必有选择地包含“复杂”调试语句上的语句。 所有语句都以这种方式包含在内。
3- 调用 log.debug 在记录之前执行以下操作：

if(repository.isDisabled(Level.DEBUG_INT))
返回;


这和调用log基本是一样的。 或猫。 isDebugEnabled()。

然而！ 这是 log4j 开发人员的想法（因为它在他们的 javadoc 中，您可能应该遵循它。）

这是方法

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

这是它的 javadoc

/**
*  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.
*   */

Answer 14

选项 2 更好。

其本身并不能提高性能。 但它确保性能不会降低。 就是这样。

通常我们期望
logger.debug(someString);

但通常，随着应用程序的增长，易手，尤其是新手开发人员，您可以看到

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

等等。

即使日志级别设置为 ERROR 或 FATAL，字符串的串联也会发生！
如果应用程序包含大量带有字符串连接的调试级别消息，那么它肯定会影响性能，尤其是对于 jdk 1.4 或更低版本。 （我不确定更高版本的jdk内部是否执行任何stringbuffer.append()）。

这就是为什么选项 2 是安全的。 甚至字符串连接也不会发生。

Answer 15

它提高了速度，因为在调试文本中连接字符串是很常见的，这是昂贵的，例如：

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

Answer 16

就像@erickson，这取决于。 如果我记得的话，isDebugEnabled 已经在 Log4j 的 debug() 方法中构建。
只要您不在调试语句中进行一些昂贵的计算，例如循环对象、执行计算和连接字符串，我认为就可以了。

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

会更好，因为

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());
}