public AsyncAppender() 
{
        
    appenders = new AppenderAttachableImpl();
    //
    //   only set for compatibility
    aai = appenders;
    dispatcher =
      new Thread(new Dispatcher(this, buffer, discardMap, appenders));
    // It is the user's responsibility to close appenders before
    // exiting.
    dispatcher.setDaemon(true);
    // set the dispatcher priority to lowest possible value
    //        dispatcher.setPriority(Thread.MIN_PRIORITY);
    dispatcher.setName("Dispatcher-" + dispatcher.getName());
    dispatcher.start();
}

Create new instance.

 public  void addAppender(Appender newAppender) 
{
    synchronized (appenders) {
      appenders.addAppender(newAppender);
    }
}

Add appender.

 public  void append(LoggingEvent event) 
{
    //
    //   if dispatcher thread has died then
    //      append subsequent events synchronously
    //   See bug 23021
    if ((dispatcher == null) || !dispatcher.isAlive() || (bufferSize < = 0)) {
      synchronized (appenders) {
        appenders.appendLoopOnAppenders(event);
      }
      return;
    }
    // Set the NDC and thread name for the calling thread as these
    // LoggingEvent fields were not set at event creation time.
    event.getNDC();
    event.getThreadName();
    // Get a copy of this thread's MDC.
    event.getMDCCopy();
    if (locationInfo) {
      event.getLocationInformation();
    }
    synchronized (buffer) {
      while (true) {
        int previousSize = buffer.size();
        if (previousSize <  bufferSize) {
          buffer.add(event);
          //
          //   if buffer had been empty
          //       signal all threads waiting on buffer
          //       to check their conditions.
          //
          if (previousSize == 0) {
            buffer.notifyAll();
          }
          break;
        }
        //
        //   Following code is only reachable if buffer is full
        //
        //
        //   if blocking and thread is not already interrupted
        //      and not the dispatcher then
        //      wait for a buffer notification
        boolean discard = true;
        if (blocking
                && !Thread.interrupted()
                && Thread.currentThread() != dispatcher) {
          try {
            buffer.wait();
            discard = false;
          } catch (InterruptedException e) {
            //
            //  reset interrupt status so
            //    calling code can see interrupt on
            //    their next wait or sleep.
            Thread.currentThread().interrupt();
          }
        }
        //
        //   if blocking is false or thread has been interrupted
        //   add event to discard map.
        //
        if (discard) {
          String loggerName = event.getLoggerName();
          DiscardSummary summary = (DiscardSummary) discardMap.get(loggerName);
          if (summary == null) {
            summary = new DiscardSummary(event);
            discardMap.put(loggerName, summary);
          } else {
            summary.add(event);
          }
          break;
        }
      }
    }
}

{@inheritDoc}

 public  void close() 
{
    /**
     * Set closed flag and notify all threads to check their conditions.
     * Should result in dispatcher terminating.
     */
    synchronized (buffer) {
      closed = true;
      buffer.notifyAll();
    }
    try {
      dispatcher.join();
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      org.apache.log4j.helpers.LogLog.error(
        "Got an InterruptedException while waiting for the "
        + "dispatcher to finish.", e);
    }
    //
    //    close all attached appenders.
    //
    synchronized (appenders) {
      Enumeration iter = appenders.getAllAppenders();
      if (iter != null) {
        while (iter.hasMoreElements()) {
          Object next = iter.nextElement();
          if (next instanceof Appender) {
            ((Appender) next).close();
          }
        }
      }
    }
}

Close this AsyncAppender by interrupting the dispatcher thread which will process all pending events before exiting.

 public Enumeration getAllAppenders() 
{
    synchronized (appenders) {
      return appenders.getAllAppenders();
    }
}

Get iterator over attached appenders.

 public Appender getAppender(String name) 
{
    synchronized (appenders) {
      return appenders.getAppender(name);
    }
}

Get appender by name.

 public boolean getBlocking() 
{
    return blocking;
}

Gets whether appender should block calling thread when buffer is full. If false, messages will be counted by logger and a summary message appended after the contents of the buffer have been appended.

 public int getBufferSize() 
{
    return bufferSize;
}

Gets the current buffer size.

 public boolean getLocationInfo() 
{
    return locationInfo;
}

Gets whether the location of the logging request call should be captured.

 public boolean isAttached(Appender appender) 
{
    synchronized (appenders) {
      return appenders.isAttached(appender);
    }
}

Determines if specified appender is attached.

 public  void removeAllAppenders() 
{
    synchronized (appenders) {
      appenders.removeAllAppenders();
    }
}

Removes and closes all attached appenders.

 public  void removeAppender(Appender appender) 
{
    synchronized (appenders) {
      appenders.removeAppender(appender);
    }
}

Removes an appender.

 public  void removeAppender(String name) 
{
    synchronized (appenders) {
      appenders.removeAppender(name);
    }
}

Remove appender by name.

 public boolean requiresLayout() 
{
    return false;
}

{@inheritDoc}

 public  void setBlocking(boolean value) 
{
    synchronized (buffer) {
      blocking = value;
      buffer.notifyAll();
    }
}

Sets whether appender should wait if there is no space available in the event buffer or immediately return.

 public  void setBufferSize(int size) 
{
    //
    //   log4j 1.2 would throw exception if size was negative
    //      and deadlock if size was zero.
    //
    if (size <  0) {
      throw new java.lang.NegativeArraySizeException("size");
    }
    synchronized (buffer) {
      //
      //   don't let size be zero.
      //
      bufferSize = (size <  1) ? 1 : size;
      buffer.notifyAll();
    }
}

Sets the number of messages allowed in the event buffer before the calling thread is blocked (if blocking is true) or until messages are summarized and discarded. Changing the size will not affect messages already in the buffer.

 public  void setLocationInfo(boolean flag) 
{
    locationInfo = flag;
}

The LocationInfo option takes a boolean value. By default, it is set to false which means there will be no effort to extract the location information related to the event. As a result, the event that will be ultimately logged will likely to contain the wrong location information (if present in the log format).

Location information extraction is comparatively very slow and should be avoided unless performance is not a concern.