diff --git a/configure.ac b/configure.ac
index d8ad3d4..561928c 100644
--- a/configure.ac
+++ b/configure.ac
@@ -64,8 +64,6 @@
         ;;
 esac
 
-CXXFLAGS="$CXXFLAGS -std=c++11"
-
 # Doxygen
 
 AC_ARG_ENABLE(doxygen,
@@ -445,6 +443,17 @@
 esac
 
 
+AC_ARG_ENABLE(non-blocking,
+            AC_HELP_STRING(--enable-non-blocking,
+           [non-blocking mode (no)]))
+if test "x$enable_non_blocking" = xyes; then
+        CXXFLAGS="$CXXFLAGS -std=c++11"
+        AC_DEFINE(NON_BLOCKING)
+        AC_DEFINE(RW_MUTEX)
+        AC_DEFINE(STATIC_STRINGSTREAM)
+fi
+
+AM_CONDITIONAL([NON_BLOCKING], [test "x$enable_non_blocking" = xyes])
 
 # Create files
 # ----------------------------------------------------------------------------
diff --git a/src/main/cpp/Makefile.am b/src/main/cpp/Makefile.am
index 8c1e007..6da89cb 100644
--- a/src/main/cpp/Makefile.am
+++ b/src/main/cpp/Makefile.am
@@ -23,7 +23,6 @@
         appenderattachableimpl.cpp \
         appenderskeleton.cpp \
         aprinitializer.cpp \
-        asyncappender.cpp \
         basicconfigurator.cpp \
         bufferedwriter.cpp \
         bytearrayinputstream.cpp \
@@ -169,5 +168,11 @@
         xmlsocketappender.cpp \
         zipcompressaction.cpp
 
+if NON_BLOCKING
+liblog4cxx_la_SOURCES += asyncappender_nonblocking.cpp
+else
+liblog4cxx_la_SOURCES += asyncappender.cpp
+endif
+
 AM_CPPFLAGS += @CPPFLAGS_ODBC@
 liblog4cxx_la_LDFLAGS = -version-info @LT_VERSION@ @LIBS_ODBC@ -@APR_LIBS@
diff --git a/src/main/cpp/asyncappender.cpp b/src/main/cpp/asyncappender.cpp
index 0484136..336d609 100644
--- a/src/main/cpp/asyncappender.cpp
+++ b/src/main/cpp/asyncappender.cpp
@@ -44,8 +44,8 @@
 
 AsyncAppender::AsyncAppender()
 : AppenderSkeleton(),
-  buffer(DEFAULT_BUFFER_SIZE),
-  SHARED_MUTEX_INIT(bufferMutex, pool),
+  buffer(),
+  bufferMutex(pool),
   bufferNotFull(pool),
   bufferNotEmpty(pool),
   discardMap(new DiscardMap()),
@@ -125,19 +125,16 @@
 
 
         {
-             LOCK_R sync(bufferMutex);
+             synchronized sync(bufferMutex);
              while(true) {
-
-                event->addRef();
-                if (buffer.bounded_push(event))
-                {
-                    bufferNotEmpty.signalAll();
-                    break;
-                }
-                else
-                {
-                    event->releaseRef();
-                }
+                 int previousSize = buffer.size();
+                 if (previousSize < bufferSize) {
+                     buffer.push_back(event);
+                     if (previousSize == 0) {
+                        bufferNotEmpty.signalAll();
+                     }
+                     break;
+                 }
 
                 //
                 //   Following code is only reachable if buffer is full
@@ -151,7 +148,7 @@
                     && !Thread::interrupted()
                     && !dispatcher.isCurrentThread()) {
                     try {
-                        bufferNotFull.await();
+                        bufferNotFull.await(bufferMutex);
                         discard = false;
                     } catch (InterruptedException& e) {
                         //
@@ -167,7 +164,14 @@
                 //   add event to discard map.
                 //
                 if (discard) {
-                    discardedCount++;
+                    LogString loggerName = event->getLoggerName();
+                    DiscardMap::iterator iter = discardMap->find(loggerName);
+                    if (iter == discardMap->end()) {
+                        DiscardSummary summary(event);
+                        discardMap->insert(DiscardMap::value_type(loggerName, summary));
+                    } else {
+                        (*iter).second.add(event);
+                    }
                     break;
                 }
             }
@@ -181,13 +185,12 @@
 
 void AsyncAppender::close() {
     {
-        LOCK_W sync(bufferMutex);
+        synchronized sync(bufferMutex);
         closed = true;
+        bufferNotEmpty.signalAll();
+        bufferNotFull.signalAll();
     }
 
-    bufferNotEmpty.signalAll();
-    bufferNotFull.signalAll();
-
 #if APR_HAS_THREADS
     try {
         dispatcher.join();
@@ -262,12 +265,8 @@
     if (size < 0) {
           throw IllegalArgumentException(LOG4CXX_STR("size argument must be non-negative"));
     }
-
-    {
-        LOCK_W sync(bufferMutex);
-        bufferSize = (size < 1) ? 1 : size;
-        buffer.reserve_unsafe(bufferSize);
-    }
+    synchronized sync(bufferMutex);
+    bufferSize = (size < 1) ? 1 : size;
     bufferNotFull.signalAll();
 }
 
@@ -277,10 +276,8 @@
 }
 
 void AsyncAppender::setBlocking(bool value) {
-    {
-        LOCK_W sync(bufferMutex);
-        blocking = value;
-    }
+    synchronized sync(bufferMutex);
+    blocking = value;
     bufferNotFull.signalAll();
 }
 
@@ -323,7 +320,7 @@
 
 ::log4cxx::spi::LoggingEventPtr
 AsyncAppender::DiscardSummary::createEvent(::log4cxx::helpers::Pool& p,
-                                           unsigned discardedCount)
+                                           size_t discardedCount)
 {
 	LogString msg(LOG4CXX_STR("Discarded "));
 	StringHelper::toString(discardedCount, p, msg);
@@ -339,39 +336,37 @@
 #if APR_HAS_THREADS
 void* LOG4CXX_THREAD_FUNC AsyncAppender::dispatch(apr_thread_t* /*thread*/, void* data) {
     AsyncAppender* pThis = (AsyncAppender*) data;
+    bool isActive = true;
     try {
-        while (!pThis->closed) {
-
-             pThis->bufferNotEmpty.await();
-
+        while (isActive) {
              //
              //   process events after lock on buffer is released.
              //
             Pool p;
             LoggingEventList events;
             {
-                   LOCK_R sync(pThis->bufferMutex);
+                   synchronized sync(pThis->bufferMutex);
+                   size_t bufferSize = pThis->buffer.size();
+                   isActive = !pThis->closed;
 
-                   unsigned count = 0;
-                   log4cxx::spi::LoggingEvent * logPtr = nullptr;
-                   while (pThis->buffer.pop(logPtr))
-                   {
-                        log4cxx::spi::LoggingEventPtr ptr(logPtr);
-                        events.push_back(ptr);
-                        logPtr->releaseRef();
-                        count++;
+                   while((bufferSize == 0) && isActive) {
+                       pThis->bufferNotEmpty.await(pThis->bufferMutex);
+                       bufferSize = pThis->buffer.size();
+                       isActive = !pThis->closed;
                    }
-
-                   if (pThis->blocking) {
-                       pThis->bufferNotFull.signalAll();
+                   for(LoggingEventList::iterator eventIter = pThis->buffer.begin();
+                       eventIter != pThis->buffer.end();
+                       eventIter++) {
+                       events.push_back(*eventIter);
                    }
-
-                   unsigned discarded = pThis->discardedCount.exchange(0);
-
-                   if (discarded != 0)
-                   {
-                       events.push_back(AsyncAppender::DiscardSummary::createEvent(p, discarded));
+                   for(DiscardMap::iterator discardIter = pThis->discardMap->begin();
+                       discardIter != pThis->discardMap->end();
+                       discardIter++) {
+                       events.push_back(discardIter->second.createEvent(p));
                    }
+                   pThis->buffer.clear();
+                   pThis->discardMap->clear();
+                   pThis->bufferNotFull.signalAll();
             }
 
             for (LoggingEventList::iterator iter = events.begin();
diff --git a/src/main/cpp/asyncappender_nonblocking.cpp b/src/main/cpp/asyncappender_nonblocking.cpp
new file mode 100644
index 0000000..b6cedfa
--- /dev/null
+++ b/src/main/cpp/asyncappender_nonblocking.cpp
@@ -0,0 +1,390 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined(_MSC_VER)
+#pragma warning ( disable: 4231 4251 4275 4786 )
+#endif
+
+#include <log4cxx/asyncappender.h>
+
+
+#include <log4cxx/helpers/loglog.h>
+#include <log4cxx/spi/loggingevent.h>
+#include <apr_thread_proc.h>
+#include <apr_thread_mutex.h>
+#include <apr_thread_cond.h>
+#include <log4cxx/helpers/condition.h>
+#include <log4cxx/helpers/synchronized.h>
+#include <log4cxx/helpers/stringhelper.h>
+#include <apr_atomic.h>
+#include <log4cxx/helpers/optionconverter.h>
+
+
+using namespace log4cxx;
+using namespace log4cxx::helpers;
+using namespace log4cxx::spi;
+
+
+IMPLEMENT_LOG4CXX_OBJECT(AsyncAppender)
+
+
+AsyncAppender::AsyncAppender()
+: AppenderSkeleton(),
+  buffer(DEFAULT_BUFFER_SIZE),
+  SHARED_MUTEX_INIT(bufferMutex, pool),
+  bufferNotFull(pool),
+  bufferNotEmpty(pool),
+  discardMap(new DiscardMap()),
+  bufferSize(DEFAULT_BUFFER_SIZE),
+  appenders(new AppenderAttachableImpl(pool)),
+  dispatcher(),
+  locationInfo(false),
+  blocking(true) {
+#if APR_HAS_THREADS
+  dispatcher.run(dispatch, this);
+#endif
+}
+
+AsyncAppender::~AsyncAppender()
+{
+        finalize();
+        delete discardMap;
+}
+
+void AsyncAppender::addRef() const {
+    ObjectImpl::addRef();
+}
+
+void AsyncAppender::releaseRef() const {
+    ObjectImpl::releaseRef();
+}
+
+void AsyncAppender::addAppender(const AppenderPtr& newAppender)
+{
+        synchronized sync(appenders->getMutex());
+        appenders->addAppender(newAppender);
+}
+
+
+void AsyncAppender::setOption(const LogString& option,
+        const LogString& value) {
+        if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("LOCATIONINFO"), LOG4CXX_STR("locationinfo"))) {
+             setLocationInfo(OptionConverter::toBoolean(value, false));
+        }
+        if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BUFFERSIZE"), LOG4CXX_STR("buffersize"))) {
+             setBufferSize(OptionConverter::toInt(value, DEFAULT_BUFFER_SIZE));
+        }
+        if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BLOCKING"), LOG4CXX_STR("blocking"))) {
+             setBlocking(OptionConverter::toBoolean(value, true));
+        } else {
+             AppenderSkeleton::setOption(option, value);
+        }
+}
+
+
+void AsyncAppender::doAppend(const spi::LoggingEventPtr& event, Pool& pool1)
+{
+        LOCK_R sync(mutex);
+
+        doAppendImpl(event, pool1);
+}
+
+void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) {
+#if APR_HAS_THREADS
+       //
+        //   if dispatcher has died then
+        //      append subsequent events synchronously
+        //
+        if (!dispatcher.isAlive() || bufferSize <= 0) {
+            synchronized sync(appenders->getMutex());
+            appenders->appendLoopOnAppenders(event, p);
+            return;
+        }
+
+        // Set the NDC and thread name for the calling thread as these
+        // LoggingEvent fields were not set at event creation time.
+        LogString ndcVal;
+        event->getNDC(ndcVal);
+        event->getThreadName();
+        // Get a copy of this thread's MDC.
+        event->getMDCCopy();
+
+
+        {
+             LOCK_R sync(bufferMutex);
+             while(true) {
+
+                event->addRef();
+                if (buffer.bounded_push(event))
+                {
+                    bufferNotEmpty.signalAll();
+                    break;
+                }
+                else
+                {
+                    event->releaseRef();
+                }
+
+                //
+                //   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
+                bool discard = true;
+                if (blocking
+                    && !Thread::interrupted()
+                    && !dispatcher.isCurrentThread()) {
+                    try {
+                        bufferNotFull.await();
+                        discard = false;
+                    } catch (InterruptedException& e) {
+                        //
+                        //  reset interrupt status so
+                        //    calling code can see interrupt on
+                        //    their next wait or sleep.
+                        Thread::currentThreadInterrupt();
+                    }
+                }
+
+                //
+                //   if blocking is false or thread has been interrupted
+                //   add event to discard map.
+                //
+                if (discard) {
+                    discardedCount++;
+                    break;
+                }
+            }
+        }
+#else
+        synchronized sync(appenders->getMutex());
+        appenders->appendLoopOnAppenders(event, p);
+#endif
+  }
+
+
+void AsyncAppender::close() {
+    {
+        LOCK_W sync(bufferMutex);
+        closed = true;
+    }
+
+    bufferNotEmpty.signalAll();
+    bufferNotFull.signalAll();
+
+#if APR_HAS_THREADS
+    try {
+        dispatcher.join();
+   } catch(InterruptedException& e) {
+        Thread::currentThreadInterrupt();
+        LogLog::error(LOG4CXX_STR("Got an InterruptedException while waiting for the dispatcher to finish,"), e);
+    }
+#endif
+
+    {
+        synchronized sync(appenders->getMutex());
+        AppenderList appenderList = appenders->getAllAppenders();
+        for (AppenderList::iterator iter = appenderList.begin();
+             iter != appenderList.end();
+             iter++) {
+             (*iter)->close();
+        }
+    }
+}
+
+AppenderList AsyncAppender::getAllAppenders() const
+{
+        synchronized sync(appenders->getMutex());
+        return appenders->getAllAppenders();
+}
+
+AppenderPtr AsyncAppender::getAppender(const LogString& n) const
+{
+        synchronized sync(appenders->getMutex());
+        return appenders->getAppender(n);
+}
+
+bool AsyncAppender::isAttached(const AppenderPtr& appender) const
+{
+        synchronized sync(appenders->getMutex());
+        return appenders->isAttached(appender);
+}
+
+bool AsyncAppender::requiresLayout() const {
+    return false;
+}
+
+void AsyncAppender::removeAllAppenders()
+{
+    synchronized sync(appenders->getMutex());
+    appenders->removeAllAppenders();
+}
+
+void AsyncAppender::removeAppender(const AppenderPtr& appender)
+{
+    synchronized sync(appenders->getMutex());
+    appenders->removeAppender(appender);
+}
+
+void AsyncAppender::removeAppender(const LogString& n)
+{
+    synchronized sync(appenders->getMutex());
+    appenders->removeAppender(n);
+}
+
+bool AsyncAppender::getLocationInfo() const {
+    return locationInfo;
+}
+
+void AsyncAppender::setLocationInfo(bool flag) {
+    locationInfo = flag;
+}
+
+
+void AsyncAppender::setBufferSize(int size)
+{
+    if (size < 0) {
+          throw IllegalArgumentException(LOG4CXX_STR("size argument must be non-negative"));
+    }
+
+    {
+        LOCK_W sync(bufferMutex);
+        bufferSize = (size < 1) ? 1 : size;
+        buffer.reserve_unsafe(bufferSize);
+    }
+    bufferNotFull.signalAll();
+}
+
+int AsyncAppender::getBufferSize() const
+{
+        return bufferSize;
+}
+
+void AsyncAppender::setBlocking(bool value) {
+    {
+        LOCK_W sync(bufferMutex);
+        blocking = value;
+    }
+    bufferNotFull.signalAll();
+}
+
+bool AsyncAppender::getBlocking() const {
+    return blocking;
+}
+
+AsyncAppender::DiscardSummary::DiscardSummary(const LoggingEventPtr& event) :
+      maxEvent(event), count(1) {
+}
+
+AsyncAppender::DiscardSummary::DiscardSummary(const DiscardSummary& src) :
+      maxEvent(src.maxEvent), count(src.count) {
+}
+
+AsyncAppender::DiscardSummary& AsyncAppender::DiscardSummary::operator=(const DiscardSummary& src) {
+      maxEvent = src.maxEvent;
+      count = src.count;
+      return *this;
+}
+
+void AsyncAppender::DiscardSummary::add(const LoggingEventPtr& event) {
+      if (event->getLevel()->toInt() > maxEvent->getLevel()->toInt()) {
+        maxEvent = event;
+      }
+      count++;
+}
+
+LoggingEventPtr AsyncAppender::DiscardSummary::createEvent(Pool& p) {
+    LogString msg(LOG4CXX_STR("Discarded "));
+    StringHelper::toString(count, p, msg);
+    msg.append(LOG4CXX_STR(" messages due to a full event buffer including: "));
+    msg.append(maxEvent->getMessage());
+    return new LoggingEvent(
+              maxEvent->getLoggerName(),
+              maxEvent->getLevel(),
+              msg,
+              LocationInfo::getLocationUnavailable());
+}
+
+::log4cxx::spi::LoggingEventPtr
+AsyncAppender::DiscardSummary::createEvent(::log4cxx::helpers::Pool& p,
+                                           size_t discardedCount)
+{
+	LogString msg(LOG4CXX_STR("Discarded "));
+	StringHelper::toString(discardedCount, p, msg);
+	msg.append(LOG4CXX_STR(" messages due to a full event buffer"));
+
+    return new LoggingEvent(
+		      LOG4CXX_STR(""),
+              log4cxx::Level::getError(),
+              msg,
+              LocationInfo::getLocationUnavailable());
+}
+
+#if APR_HAS_THREADS
+void* LOG4CXX_THREAD_FUNC AsyncAppender::dispatch(apr_thread_t* /*thread*/, void* data) {
+    AsyncAppender* pThis = (AsyncAppender*) data;
+    try {
+        while (!pThis->closed) {
+
+             pThis->bufferNotEmpty.await();
+
+             //
+             //   process events after lock on buffer is released.
+             //
+            Pool p;
+            LoggingEventList events;
+            {
+                   LOCK_R sync(pThis->bufferMutex);
+
+                   unsigned count = 0;
+                   log4cxx::spi::LoggingEvent * logPtr = nullptr;
+                   while (pThis->buffer.pop(logPtr))
+                   {
+                        log4cxx::spi::LoggingEventPtr ptr(logPtr);
+                        events.push_back(ptr);
+                        logPtr->releaseRef();
+                        count++;
+                   }
+
+                   if (pThis->blocking) {
+                       pThis->bufferNotFull.signalAll();
+                   }
+
+                   size_t discarded = pThis->discardedCount.exchange(0);
+
+                   if (discarded != 0)
+                   {
+                       events.push_back(AsyncAppender::DiscardSummary::createEvent(p, discarded));
+                   }
+            }
+
+            for (LoggingEventList::iterator iter = events.begin();
+                 iter != events.end();
+                 iter++) {
+                 synchronized sync(pThis->appenders->getMutex());
+                 pThis->appenders->appendLoopOnAppenders(*iter, p);
+            }
+        }
+    } catch(InterruptedException& ex) {
+            Thread::currentThreadInterrupt();
+    } catch(...) {
+    }
+    return 0;
+}
+#endif
diff --git a/src/main/cpp/messagebuffer.cpp b/src/main/cpp/messagebuffer.cpp
index 39a5f2a..e13d312 100644
--- a/src/main/cpp/messagebuffer.cpp
+++ b/src/main/cpp/messagebuffer.cpp
@@ -40,7 +40,9 @@
 }
 
 CharMessageBuffer::CharMessageBuffer() : stream(0) {
-   if (gMessageBufferUseStaticStream)
+
+#if defined(STATIC_STRINGSTREAM)
+if (gMessageBufferUseStaticStream)
    {
       thread_local static char ossBuf[8192];
       thread_local static std::basic_ostringstream<char> sStream;
@@ -54,6 +56,7 @@
       }
       stream = &sStream;
    }
+#endif
 }
 
 CharMessageBuffer::~CharMessageBuffer() {
@@ -143,6 +146,8 @@
 
 #if LOG4CXX_WCHAR_T_API
 WideMessageBuffer::WideMessageBuffer() : stream(0) {
+
+#if defined(STATIC_STRINGSTREAM)
    if (gMessageBufferUseStaticStream)
    {
       thread_local static wchar_t ossBuf[8192];
@@ -157,6 +162,7 @@
       }
       stream = &sStream;
    }
+#endif
 }
 
 WideMessageBuffer::~WideMessageBuffer() {
@@ -372,6 +378,8 @@
 
 
 UniCharMessageBuffer::UniCharMessageBuffer() : stream(0) {
+
+#if defined(STATIC_STRINGSTREAM)
    if (gMessageBufferUseStaticStream)
    {
       thread_local static log4cxx::UniChar ossBuf[8192];
@@ -386,6 +394,7 @@
       }
       stream = &sStream;
    }
+#endif
 }
 
 UniCharMessageBuffer::~UniCharMessageBuffer() {
diff --git a/src/main/cpp/mutex.cpp b/src/main/cpp/mutex.cpp
index b57595d..d76afca 100755
--- a/src/main/cpp/mutex.cpp
+++ b/src/main/cpp/mutex.cpp
@@ -27,6 +27,8 @@
 #endif
 #include <log4cxx/helpers/aprinitializer.h>
 
+#if defined(NON_BLOCKING)
+
 #if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
 #include <windows.h>
 #else
@@ -34,6 +36,8 @@
 #include <semaphore.h>
 #endif
 
+#endif // NON_BLOCKING
+
 using namespace log4cxx::helpers;
 using namespace log4cxx;
 
@@ -75,6 +79,8 @@
     return mutex;
 }
 
+#if defined(RW_MUTEX)
+
 RWMutex::RWMutex(Pool& p)
         : id((apr_os_thread_t)-1)
         , count(0)
@@ -152,6 +158,9 @@
 #endif
 }
 
+#endif // RW_MUTEX
+
+#if defined(NON_BLOCKING)
 
 #if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
 
@@ -164,7 +173,7 @@
 	}
 }
 
-static const LONG cMax = 10;
+static const LONG cMax = 10000; // arbitrary high value
 
 Semaphore::Semaphore(log4cxx::helpers::Pool& p)
 	: impl(nullptr)
@@ -275,4 +284,6 @@
 #endif
 }
 
-#endif
+#endif // POSIX
+
+#endif // NON_BLOCKING
diff --git a/src/main/cpp/synchronized.cpp b/src/main/cpp/synchronized.cpp
index e561f54..a732c7f 100644
--- a/src/main/cpp/synchronized.cpp
+++ b/src/main/cpp/synchronized.cpp
@@ -60,6 +60,7 @@
 #endif
 }
 
+#if defined(RW_MUTEX)
 
 synchronized_read::synchronized_read(const RWMutex& mutex1)
         : mutex(mutex1)
@@ -83,3 +84,4 @@
         mutex.wrUnlock();
 }
 
+#endif // RW_MUTEX
diff --git a/src/main/include/log4cxx/asyncappender.h b/src/main/include/log4cxx/asyncappender.h
index 7d43d81..499b435 100644
--- a/src/main/include/log4cxx/asyncappender.h
+++ b/src/main/include/log4cxx/asyncappender.h
@@ -32,7 +32,9 @@
 #include <log4cxx/helpers/mutex.h>
 #include <log4cxx/helpers/condition.h>
 
+#if defined(NON_BLOCKING)
 #include <boost/lockfree/queue.hpp>
+#endif
 
 namespace log4cxx
 {
@@ -199,16 +201,25 @@
                 /**
                  * Event buffer.
                 */
+#if defined(NON_BLOCKING)
                 boost::lockfree::queue<log4cxx::spi::LoggingEvent* > buffer;
-                std::atomic<unsigned> discardedCount;
+                std::atomic<size_t> discardedCount;
+#else
+                LoggingEventList buffer;
+#endif
 
                 /**
                  *  Mutex used to guard access to buffer and discardMap.
                  */
                 SHARED_MUTEX bufferMutex;
-                SEMAPHORE bufferNotFull;
-                SEMAPHORE bufferNotEmpty;
-
+                
+#if defined(NON_BLOCKING)
+                ::log4cxx::helpers::Semaphore bufferNotFull;
+                ::log4cxx::helpers::Semaphore bufferNotEmpty;
+#else
+                ::log4cxx::helpers::Condition bufferNotFull;
+                ::log4cxx::helpers::Condition bufferNotEmpty;
+#endif
                 class DiscardSummary {
                 private:
                     /**
@@ -249,7 +260,7 @@
 
                      static
                      ::log4cxx::spi::LoggingEventPtr createEvent(::log4cxx::helpers::Pool& p,
-                                                                 unsigned discardedCount);
+                                                                 size_t discardedCount);
                 };
 
                 /**
diff --git a/src/main/include/log4cxx/helpers/mutex.h b/src/main/include/log4cxx/helpers/mutex.h
index ea8b18e..aecc6bd 100644
--- a/src/main/include/log4cxx/helpers/mutex.h
+++ b/src/main/include/log4cxx/helpers/mutex.h
@@ -54,6 +54,8 @@
 } // namespace log4cxx
 
 
+#if defined(RW_MUTEX)
+
 namespace log4cxx
 {
         namespace helpers
@@ -84,8 +86,17 @@
 } // namespace log4cxx
 
 #define SHARED_MUTEX log4cxx::helpers::RWMutex
+
+#else // no RW_MUTEX
+
+#define SHARED_MUTEX log4cxx::helpers::Mutex
+
+#endif // RW_MUTEX
+
 #define SHARED_MUTEX_INIT(mutex, p) mutex(p)
 
+#if defined(NON_BLOCKING)
+
 namespace log4cxx
 {
     namespace helpers
@@ -110,6 +121,6 @@
     } // namespace helpers
 } // namespace log4cxx
 
-#define SEMAPHORE log4cxx::helpers::Semaphore
+#endif // NON_BLOCKING
 
 #endif //_LOG4CXX_HELPERS_MUTEX_H
diff --git a/src/main/include/log4cxx/helpers/synchronized.h b/src/main/include/log4cxx/helpers/synchronized.h
index e4df183..741b24e 100644
--- a/src/main/include/log4cxx/helpers/synchronized.h
+++ b/src/main/include/log4cxx/helpers/synchronized.h
@@ -46,6 +46,8 @@
         }
 }
 
+#if defined(RW_MUTEX)
+
 namespace log4cxx
 {
         namespace helpers {
@@ -93,4 +95,11 @@
 #define LOCK_R synchronized_read
 #define LOCK_W synchronized_write
 
+#else
+
+#define LOCK_R synchronized
+#define LOCK_W synchronized
+
+#endif // RW_MUTEX
+
 #endif //_LOG4CXX_HELPERS_SYNCHRONIZED_H