log4j之个人浅析

    最近稍微大致地阅读了log4j的源码，毕竟这是Java开源日志框架里几乎最常用的一个实现。在大多数实际应用中，还需要诸如common-logging、slf4j等Facade模式日志框架对log4j进行封装，实际日志记录、输出等级、格式化等工作都是由log4j完成。本文把注意力集中在log4j身上，探讨一下这个开源日志框架的内部。

特性

    关于log4j的具体配置以及例子这里就不多说了，主要集中说一下其配置特性。作为一个开源日志框架，为了满足大部分日志需求，log4j的配置较为灵活，并且也较为容易理解，实际配置起来也并不复杂。

    主要有以下可配置特性：

• 日志等级：DEBUG、INFO、WARN、ERROR等；
• 输出方式（Appender）：log4j自带就有AsyncAppender、ConsoleAppender、RollingFileAppender、DailyRollingFileAppender等，还可以自己实现对应接口来定制。
• 输出格式（Layout）：log4j同样自带了有PatternLayout、DateLayout等
• 可按照package的”父子“关系来让子package继承父package配置。

架构大致

    主要是通过LogManager提供接口，然后Hierachy管理Logger的继承层次，LogEvent封装要记录日志的信息，另外还有Layout和Appender的层次封装实现功能等。

一些实现细节

    log4j为了提高日志记录带来的性能影响，对于一些实现细节做了大量的优化。

• 日期和大小限制的日志判断

    如果设置了日志记录的时间以及文件大小限制，这样每到限制时，就会进行rollover，也就是关闭当前文件，打开新的文件重新进行日志记录。因为这样需要每次打log都要进行判断，为了提高性能，对于日期大小，都会预先计算好下一次需要rollover的时间nextCheck，然后每次记录日志时只需要拿当前时间判断即可。代码如下：

 //DailyRollingFileAppender
protected void subAppend(LoggingEvent event) {
    long n = System.currentTimeMillis();
    if (n >= nextCheck) {
      now.setTime(n);
      nextCheck = rc.getNextCheckMillis(now);
      try {
	rollOver();
      }
      catch(IOException ioe) {
          if (ioe instanceof InterruptedIOException) {
              Thread.currentThread().interrupt();
          }
	      LogLog.error("rollOver() failed.", ioe);
      }
    }
    super.subAppend(event);
   }
}

    对于文件大小限制，由于每次取文件大小较为麻烦，有种办法就是把每次log的size大小添加到count变量，然后再判断是否超过大小，超过则进行rollover操作。代码如下：

//RollingFileAppender  
protected
  void subAppend(LoggingEvent event) {
    super.subAppend(event);
    if(fileName != null && qw != null) {
        long size = ((CountingQuietWriter) qw).getCount();
        if (size >= maxFileSize && size >= nextRollover) {
            rollOver();
        }
    }
   }
}

//CountingQuietWriter
  public
  void write(String string) {
    try {
      out.write(string);
      count += string.length();
    }
    catch(IOException e) {
      errorHandler.error("Write failure.", e, ErrorCode.WRITE_FAILURE);
    }
  }

  public
  long getCount() {
    return count;
  }

• 填充pattern的空白区域

    填充pattern的时候，如果内容没有超过最小size，则需要进行空白字符填充。log4j采用了一种fast space padding的方法，主要是把需要填充的长度分成两部分考虑，超过32的部分，则循环添加32个空格，少于32的话，则采用长度的bit位进行与判断来添加对应的1，2，4，8，16个空格字符。这样如果要填充的空白字符少于32，顶多需要4次循环即可解决。代码如下：

  static String[] SPACES = {" ", "  ", "    ", "        ", //1,2,4,8 spaces
			    "                ", // 16 spaces
			    "                                " }; // 32 spaces

  /**
     Fast space padding method.
  */
  public
  void spacePad(StringBuffer sbuf, int length) {
    while(length >= 32) {
      sbuf.append(SPACES[5]);
      length -= 32;
    }
    
    for(int i = 4; i >= 0; i--) {	
      if((length & (1<<i)) != 0) {
	sbuf.append(SPACES[i]);
      }
    }
  }
}

• Logger的继承

    对于log4j，认为Java的包x.y.z是包x.y的子包，如果定义了父包x.y的属性，则子包会自动继承。为了实现这个，log4j利用了Logger内部的一个parent引用，这样当获取属性的时候，只需要通过parent指针获取其属性即可。在getLogger的时候，会动态计算出这个parent引用，由于父包和子包调用getLogger的顺序不能确定，因此要保证在性能理想的情况下，能够保证parent能够正确设置，log4j使用了一个ProvisionNode作为占位来辅助判断。代码如下：

public
  Logger getLogger(String name, LoggerFactory factory) {
    //System.out.println("getInstance("+name+") called.");
    CategoryKey key = new CategoryKey(name);
    // Synchronize to prevent write conflicts. Read conflicts (in
    // getChainedLevel method) are possible only if variable
    // assignments are non-atomic.
    Logger logger;

    synchronized(ht) {
      Object o = ht.get(key);
      if(o == null) {
	logger = factory.makeNewLoggerInstance(name);
	logger.setHierarchy(this);
	ht.put(key, logger);
	updateParents(logger);
	return logger;
      } else if(o instanceof Logger) {
	return (Logger) o;
      } else if (o instanceof ProvisionNode) {
	//System.out.println("("+name+") ht.get(this) returned ProvisionNode");
	logger = factory.makeNewLoggerInstance(name);
	logger.setHierarchy(this);
	ht.put(key, logger);
	updateChildren((ProvisionNode) o, logger);
	updateParents(logger);
	return logger;
      }
      else {
	// It should be impossible to arrive here
	return null;  // but let's keep the compiler happy.
      }
    }
  }

    如果子包的类先调用getLogger，则此时获得的Logger为NULL，这样在updateParents的时候，会不断根据x.y、x这样的顺序创建父包的 ProvisionNode作为占位，如果仍然没有找到父包，则会把root的Logger作为默认的父亲，这样就保证一定有默认属性。如果是父包的类先调用getLogger，则会获得ProvisionNode，这样就需要把ProvisionNode记录的子Logger更新parent引用。这样就保证在getLogger的时候保证顺序正常，同时也保证了通过parent获取继承属性也比较快。updateChildren和updateParents方法如下：

  final
  private
  void updateParents(Logger cat) {
    String name = cat.name;
    int length = name.length();
    boolean parentFound = false;

    //System.out.println("UpdateParents called for " + name);

    // if name = "w.x.y.z", loop thourgh "w.x.y", "w.x" and "w", but not "w.x.y.z"
    for(int i = name.lastIndexOf('.', length-1); i >= 0;
	                                 i = name.lastIndexOf('.', i-1))  {
      String substr = name.substring(0, i);

      //System.out.println("Updating parent : " + substr);
      CategoryKey key = new CategoryKey(substr); // simple constructor
      Object o = ht.get(key);
      // Create a provision node for a future parent.
      if(o == null) {
	//System.out.println("No parent "+substr+" found. Creating ProvisionNode.");
	ProvisionNode pn = new ProvisionNode(cat);
	ht.put(key, pn);
      } else if(o instanceof Category) {
	parentFound = true;
	cat.parent = (Category) o;
	//System.out.println("Linking " + cat.name + " -> " + ((Category) o).name);
	break; // no need to update the ancestors of the closest ancestor
      } else if(o instanceof ProvisionNode) {
	((ProvisionNode) o).addElement(cat);
      } else {
	Exception e = new IllegalStateException("unexpected object type " +
					o.getClass() + " in ht.");
	e.printStackTrace();
      }
    }
    // If we could not find any existing parents, then link with root.
    if(!parentFound)
      cat.parent = root;
  }

  final
  private
  void updateChildren(ProvisionNode pn, Logger logger) {
    //System.out.println("updateChildren called for " + logger.name);
    final int last = pn.size();

    for(int i = 0; i < last; i++) {
      Logger l = (Logger) pn.elementAt(i);
      //System.out.println("Updating child " +p.name);

      // Unless this child already points to a correct (lower) parent,
      // make cat.parent point to l.parent and l.parent to cat.
      if(!l.parent.name.startsWith(logger.name)) {
	logger.parent = l.parent;
	l.parent = logger;
      }
    }
  }

• NDC和MDC

    NDC和MDC能够方便地为不同线程提供上下文。NDC使用HashTable记录线程的stack信息，配置log4j的使用使用%x就可以打印出该信息，方便追踪。MDC则是用ThreadLocal保存。概念挺不错，但是代码实现得比较难看，就不拿出来了。

• 实现不够好的地方

   1、由于log4j是在早期实现的一个开源日志框架，代码里还有对Java1的支持，因此在一些集合容器选择上较为“落后”。如大部分线程同步都直接选择HashTable、Stack等实现上直接使用synchronized关键字进行同步的容器，这些容器的并发远远差于1.5开始存在的concurrent的集合，如ConcurrentHashMap、CopyOnWriteArrayList等容器。因此事实上HashTable、Stack等容器其实已经是不推荐使用的。

    2、对于MDC使用ThreadLocal保存不同线程上下文的方式，或许没有注意到ThreadLocal的Entry是WeakReference，因此很容易就会被gc回收掉，这样上下文内容就会神不知鬼不觉消失。

    3、对于AsyncAppender，这个异步Appender的实现，采用的是一种消费-生产模式的线程同步。使用的也是对象监视器的wait、notifyAll以及ArrayList作为队列的同步。这里理所当然采用BlockingQueue等子类同步队列会很好多。

    4、众所周知，在写文件的时候如果使用Buffer则会大大提升性能，同样，log4j也提供了设置buffer属性，但遗憾的是，如果没有注意flush，在程序退出的时候会丢失一些日志记录，虽然log4j提供了LogManager.shutdown方法，但如果程序异常退出从而没有调用shutdown则也是很麻烦。因此缺乏一种有效的手段去解决问题。

• 对比个人之前的一个日志实现

    之前本人曾经为Android写过一个日志实现。由于Android本身对于流畅运行要求极高，为了实现最佳的日志性能，实现了一个Buffer+异步日志记录功能的模块。

    主要是利用OutputStream的传递性。大致如下：

OutputStream writer = new BufferedOutputStream(new AsyncOutputStream(new FileOutputStream));

    这样在Buffer写满的时候，便会自动转为异步写文件，这种记录日志的方式应该能最大化减轻记录日志所带来的IO负担，以及避免过量异步带来的开销。