You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by sw...@apache.org on 2023/02/04 05:44:29 UTC

[logging-log4cxx] 01/01: Prevent priority inversions when logging from multiple threads

This is an automated email from the ASF dual-hosted git repository.

swebb2066 pushed a commit to branch real_time_usage
in repository https://gitbox.apache.org/repos/asf/logging-log4cxx.git

commit 0c3aefa20830c1537300ac4196b8b70eb3257a69
Author: Stephen Webb <st...@sabreautonomous.com.au>
AuthorDate: Sat Feb 4 16:43:54 2023 +1100

    Prevent priority inversions when logging from multiple threads
---
 CMakeLists.txt                                     |  2 +
 src/CMakeLists.txt                                 |  3 +
 src/cmake/pthread/log4cxx-pthread.cmake            | 16 +++-
 src/cmake/pthread/test-pthread-setprotocol.cpp     | 18 +++++
 src/main/cpp/appenderattachableimpl.cpp            | 89 +++++-----------------
 src/main/cpp/appenderskeleton.cpp                  | 18 ++---
 src/main/cpp/asyncappender.cpp                     | 36 +++------
 src/main/cpp/fileappender.cpp                      | 18 ++---
 src/main/cpp/multiprocessrollingfileappender.cpp   |  4 +-
 src/main/cpp/rollingfileappender.cpp               |  4 +-
 src/main/cpp/socketappenderskeleton.cpp            |  4 +-
 src/main/cpp/telnetappender.cpp                    | 10 +--
 src/main/cpp/writerappender.cpp                    |  4 +-
 src/main/cpp/xmlsocketappender.cpp                 |  2 +-
 src/main/include/CMakeLists.txt                    | 19 +----
 src/main/include/log4cxx/appenderskeleton.h        | 14 ++--
 .../log4cxx/private/appenderskeleton_priv.h        | 18 ++---
 .../include/log4cxx/private/log4cxx_private.h.in   |  1 +
 src/main/include/log4cxx/private/mutex.h           | 72 +++++++++++++++++
 19 files changed, 190 insertions(+), 162 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4f55805d..9321bbd8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -202,6 +202,7 @@ get_directory_property( ATOMIC_IMPL DIRECTORY src DEFINITION ATOMIC_IMPL )
 get_directory_property( FILESYSTEM_IMPL DIRECTORY src DEFINITION FILESYSTEM_IMPL )
 get_directory_property( STD_MAKE_UNIQUE_IMPL DIRECTORY src DEFINITION STD_MAKE_UNIQUE_IMPL )
 get_directory_property( STD_LIB_HAS_UNICODE_STRING DIRECTORY src DEFINITION STD_LIB_HAS_UNICODE_STRING )
+get_directory_property( HAS_PTHREAD_SETPROTOCOL DIRECTORY src DEFINITION HAS_PTHREAD_SETPROTOCOL )
 
 foreach(varName HAS_STD_LOCALE  HAS_ODBC  HAS_MBSRTOWCS  HAS_WCSTOMBS  HAS_FWIDE  HAS_LIBESMTP  HAS_SYSLOG HAS_FMT)
   if(${varName} EQUAL 0)
@@ -282,6 +283,7 @@ message(STATUS "  Prefer boost: ................... : ${PREFER_BOOST}")
 message(STATUS "  thread implementation ........... : ${THREAD_IMPL}")
 message(STATUS "  thread_local support? ........... : ${HAS_THREAD_LOCAL}")
 message(STATUS "  mutex implementation ............ : ${MUTEX_IMPL}")
+message(STATUS "  priority inheritance? ........... : ${HAS_PTHREAD_SETPROTOCOL}")
 message(STATUS "  shared_ptr implementation ....... : ${SMART_PTR_IMPL}")
 message(STATUS "  shared_mutex implementation ..... : ${SHARED_MUTEX_IMPL}")
 message(STATUS "  atomic implementation ........... : ${ATOMIC_IMPL}")
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 788320de..b5a1e6e8 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -17,6 +17,9 @@
 cmake_policy(SET CMP0079 NEW)
 include(${CMAKE_CURRENT_LIST_DIR}/cmake/boost-fallback/boost-fallback.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/cmake/compiler-features/check-compiler-support.cmake)
+if(UNIX)
+  include(${CMAKE_CURRENT_LIST_DIR}/cmake/pthread/log4cxx-pthread.cmake)
+endif(UNIX)
 
 add_subdirectory(main)
 target_compile_definitions(log4cxx PRIVATE ${LOG4CXX_COMPILE_DEFINITIONS} ${APR_COMPILE_DEFINITIONS} ${APR_UTIL_COMPILE_DEFINITIONS} )
diff --git a/src/cmake/pthread/log4cxx-pthread.cmake b/src/cmake/pthread/log4cxx-pthread.cmake
index bd9e8590..c411b201 100644
--- a/src/cmake/pthread/log4cxx-pthread.cmake
+++ b/src/cmake/pthread/log4cxx-pthread.cmake
@@ -1,10 +1,22 @@
 include(FindThreads)
 
-try_compile(PTHREAD_SETNAME_NP_FOUND "${CMAKE_BINARY_DIR}/pthread-compile-tests"
+set(CMAKE_REQUIRED_LIBRARIES "pthread")
+CHECK_SYMBOL_EXISTS(pthread_sigmask "signal.h" HAS_PTHREAD_SIGMASK)
+
+# Check for the (linux) pthread_setname_np.
+# OSX and BSD are special apparently.  OSX only lets you name
+# the current thread, while BSD calls it pthread_set_name_np.
+# Since this is really not a core feature and the end-user can configure
+# it anyway, we're only going to worry about linux.
+try_compile(HAS_PTHREAD_SETNAME "${CMAKE_BINARY_DIR}/pthread-compile-tests"
     "${CMAKE_CURRENT_LIST_DIR}/test-pthread-setname.cpp"
     LINK_LIBRARIES Threads::Threads )
 
-try_compile(PTHREAD_GETNAME_NP_FOUND "${CMAKE_BINARY_DIR}/pthread-compile-tests"
+try_compile(HAS_PTHREAD_GETNAME "${CMAKE_BINARY_DIR}/pthread-compile-tests"
     "${CMAKE_CURRENT_LIST_DIR}/test-pthread-getname.cpp"
     LINK_LIBRARIES Threads::Threads )
 
+try_compile(HAS_PTHREAD_SETPROTOCOL "${CMAKE_BINARY_DIR}/pthread-compile-tests"
+    "${CMAKE_CURRENT_LIST_DIR}/test-pthread-setprotocol.cpp"
+    LINK_LIBRARIES Threads::Threads )
+
diff --git a/src/cmake/pthread/test-pthread-setprotocol.cpp b/src/cmake/pthread/test-pthread-setprotocol.cpp
new file mode 100644
index 00000000..133068a0
--- /dev/null
+++ b/src/cmake/pthread/test-pthread-setprotocol.cpp
@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <pthread.h>
+
+int main(){
+	int result = EXIT_SUCCESS;
+	pthread_mutex_t m;
+	pthread_mutexattr_t rrAttr;
+	if (pthread_mutexattr_init(&rrAttr) != 0)
+		result = EXIT_FAILURE;
+	else if (pthread_mutexattr_setprotocol(&rrAttr, PTHREAD_PRIO_INHERIT) != 0)
+		result = EXIT_FAILURE;
+	else if (pthread_mutex_init(&m, &rrAttr) != 0)
+		result = EXIT_FAILURE;
+	else
+		pthread_mutex_destroy(&m);
+	pthread_mutexattr_destroy(&rrAttr);
+	return result;
+}
diff --git a/src/main/cpp/appenderattachableimpl.cpp b/src/main/cpp/appenderattachableimpl.cpp
index d936d9c6..6363a8d7 100644
--- a/src/main/cpp/appenderattachableimpl.cpp
+++ b/src/main/cpp/appenderattachableimpl.cpp
@@ -55,9 +55,7 @@ void AppenderAttachableImpl::addAppender(const AppenderPtr newAppender)
 	}
 
 	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
-	AppenderList::iterator it = std::find(
-			m_priv->appenderList.begin(), m_priv->appenderList.end(), newAppender);
-
+	auto it = std::find(m_priv->appenderList.begin(), m_priv->appenderList.end(), newAppender);
 	if (it == m_priv->appenderList.end())
 	{
 		m_priv->appenderList.push_back(newAppender);
@@ -69,13 +67,12 @@ int AppenderAttachableImpl::appendLoopOnAppenders(
 	Pool& p)
 {
 	int numberAppended = 0;
-	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
 	// FallbackErrorHandler::error() may modify our list of appenders
 	// while we are iterating over them (if it holds the same logger).
 	// So, make a local copy of the appenders that we want to iterate over
 	// before actually iterating over them.
-	AppenderList allAppenders = m_priv->appenderList;
-	for (auto appender : allAppenders)
+	// doAppend() will serialize calls to AppenderSkeleton#append.
+	for (auto appender : getAllAppenders())
 	{
 		appender->doAppend(event, p);
 		numberAppended++;
@@ -92,95 +89,49 @@ AppenderList AppenderAttachableImpl::getAllAppenders() const
 
 AppenderPtr AppenderAttachableImpl::getAppender(const LogString& name) const
 {
-	if (name.empty())
-	{
-		return 0;
-	}
-
+	AppenderPtr result;
 	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
-	AppenderList::const_iterator it, itEnd = m_priv->appenderList.end();
-	AppenderPtr appender;
-
-	for (it = m_priv->appenderList.begin(); it != itEnd; it++)
-	{
-		appender = *it;
-
-		if (name == appender->getName())
-		{
-			return appender;
-		}
-	}
-
-	return 0;
+	auto it = std::find_if(m_priv->appenderList.begin(), m_priv->appenderList.end(),
+		[&name](const AppenderPtr& appender) -> bool
+		{ return name == appender->getName(); }
+	);
+	if (it != m_priv->appenderList.end())
+		result = *it;
+	return result;
 }
 
 bool AppenderAttachableImpl::isAttached(const AppenderPtr appender) const
 {
-	if (appender == 0)
-	{
-		return false;
-	}
-
 	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
-	AppenderList::const_iterator it = std::find(
-			m_priv->appenderList.begin(), m_priv->appenderList.end(), appender);
-
+	auto it = std::find(m_priv->appenderList.begin(), m_priv->appenderList.end(), appender);
 	return it != m_priv->appenderList.end();
 }
 
 void AppenderAttachableImpl::removeAllAppenders()
 {
 	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
-	AppenderList::iterator it, itEnd = m_priv->appenderList.end();
-	AppenderPtr a;
-
-	for (it = m_priv->appenderList.begin(); it != itEnd; it++)
-	{
-		a = *it;
+	for (auto a : m_priv->appenderList)
 		a->close();
-	}
-
 	m_priv->appenderList.clear();
 }
 
 void AppenderAttachableImpl::removeAppender(const AppenderPtr appender)
 {
-	if (appender == 0)
-	{
-		return;
-	}
-
 	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
-	AppenderList::iterator it = std::find(
-			m_priv->appenderList.begin(), m_priv->appenderList.end(), appender);
-
+	auto it = std::find(m_priv->appenderList.begin(), m_priv->appenderList.end(), appender);
 	if (it != m_priv->appenderList.end())
-	{
 		m_priv->appenderList.erase(it);
-	}
 }
 
 void AppenderAttachableImpl::removeAppender(const LogString& name)
 {
-	if (name.empty())
-	{
-		return;
-	}
-
 	std::lock_guard<std::recursive_mutex> lock( m_priv->m_mutex );
-	AppenderList::iterator it, itEnd = m_priv->appenderList.end();
-	AppenderPtr appender;
-
-	for (it = m_priv->appenderList.begin(); it != itEnd; it++)
-	{
-		appender = *it;
-
-		if (name == appender->getName())
-		{
-			m_priv->appenderList.erase(it);
-			return;
-		}
-	}
+	auto it = std::find_if(m_priv->appenderList.begin(), m_priv->appenderList.end(),
+		[&name](const AppenderPtr& appender) -> bool
+		{ return name == appender->getName(); }
+	);
+	if (it != m_priv->appenderList.end())
+		m_priv->appenderList.erase(it);
 }
 
 
diff --git a/src/main/cpp/appenderskeleton.cpp b/src/main/cpp/appenderskeleton.cpp
index fdc489cb..9fa9f6c2 100644
--- a/src/main/cpp/appenderskeleton.cpp
+++ b/src/main/cpp/appenderskeleton.cpp
@@ -64,7 +64,7 @@ void AppenderSkeleton::finalize()
 
 void AppenderSkeleton::addFilter(const spi::FilterPtr newFilter)
 {
-	std::lock_guard<std::recursive_mutex> lock(m_priv->mutex);
+	AppenderScopeGuard lock(m_priv->mutex);
 
 	if (m_priv->headFilter == nullptr)
 	{
@@ -79,19 +79,17 @@ void AppenderSkeleton::addFilter(const spi::FilterPtr newFilter)
 
 void AppenderSkeleton::clearFilters()
 {
-	std::lock_guard<std::recursive_mutex> lock(m_priv->mutex);
+	AppenderScopeGuard lock(m_priv->mutex);
 	m_priv->headFilter = m_priv->tailFilter = nullptr;
 }
 
 bool AppenderSkeleton::isAsSevereAsThreshold(const LevelPtr& level) const
 {
-	return ((level == 0) || level->isGreaterOrEqual(m_priv->threshold));
+	return !level || level->isGreaterOrEqual(m_priv->threshold);
 }
 
 void AppenderSkeleton::doAppend(const spi::LoggingEventPtr& event, Pool& pool1)
 {
-	std::lock_guard<std::recursive_mutex> lock(m_priv->mutex);
-
 	doAppendImpl(event, pool1);
 }
 
@@ -99,7 +97,7 @@ void AppenderSkeleton::doAppendImpl(const spi::LoggingEventPtr& event, Pool& poo
 {
 	if (m_priv->closed)
 	{
-		LogLog::error(((LogString) LOG4CXX_STR("Attempted to append to closed appender named ["))
+		LogLog::error(LOG4CXX_STR("Attempted to append to closed appender named [")
 			+ m_priv->name + LOG4CXX_STR("]."));
 		return;
 	}
@@ -109,9 +107,8 @@ void AppenderSkeleton::doAppendImpl(const spi::LoggingEventPtr& event, Pool& poo
 		return;
 	}
 
+	AppenderScopeGuard lock(m_priv->mutex);
 	FilterPtr f = m_priv->headFilter;
-
-
 	while (f != 0)
 	{
 		switch (f->decide(event))
@@ -127,13 +124,12 @@ void AppenderSkeleton::doAppendImpl(const spi::LoggingEventPtr& event, Pool& poo
 				f = f->getNext();
 		}
 	}
-
 	append(event, pool1);
 }
 
 void AppenderSkeleton::setErrorHandler(const spi::ErrorHandlerPtr errorHandler1)
 {
-	std::lock_guard<std::recursive_mutex> lock(m_priv->mutex);
+	AppenderScopeGuard lock(m_priv->mutex);
 
 	if (errorHandler1 == nullptr)
 	{
@@ -149,7 +145,7 @@ void AppenderSkeleton::setErrorHandler(const spi::ErrorHandlerPtr errorHandler1)
 
 void AppenderSkeleton::setThreshold(const LevelPtr& threshold1)
 {
-	std::lock_guard<std::recursive_mutex> lock(m_priv->mutex);
+	AppenderScopeGuard lock(m_priv->mutex);
 	m_priv->threshold = threshold1;
 }
 
diff --git a/src/main/cpp/asyncappender.cpp b/src/main/cpp/asyncappender.cpp
index 20ff3cd8..40339949 100644
--- a/src/main/cpp/asyncappender.cpp
+++ b/src/main/cpp/asyncappender.cpp
@@ -94,30 +94,22 @@ struct AsyncAppender::AsyncAppenderPriv : public AppenderSkeleton::AppenderSkele
 		appenders(std::make_shared<AppenderAttachableImpl>(pool)),
 		dispatcher(),
 		locationInfo(false),
-		blocking(true) {}
+		blocking(true)
+		{ EnablePriorityInheritance(bufferMutex, pool); }
 
 	/**
 	 * Event buffer.
 	*/
-#if defined(NON_BLOCKING)
-	boost::lockfree::queue<log4cxx::spi::LoggingEvent* > buffer;
-	std::atomic<size_t> discardedCount;
-#else
 	LoggingEventList buffer;
-#endif
 
 	/**
 	 *  Mutex used to guard access to buffer and discardMap.
 	 */
-	std::mutex bufferMutex;
+	AppenderMutexType bufferMutex;
+
 
-#if defined(NON_BLOCKING)
-	::log4cxx::helpers::Semaphore bufferNotFull;
-	::log4cxx::helpers::Semaphore bufferNotEmpty;
-#else
 	std::condition_variable bufferNotFull;
 	std::condition_variable bufferNotEmpty;
-#endif
 
 	/**
 	  * Map of DiscardSummary objects keyed by logger name.
@@ -197,8 +189,6 @@ void AsyncAppender::setOption(const LogString& option,
 
 void AsyncAppender::doAppend(const spi::LoggingEventPtr& event, Pool& pool1)
 {
-	std::lock_guard<std::recursive_mutex> lock(priv->mutex);
-
 	doAppendImpl(event, pool1);
 }
 
@@ -222,7 +212,7 @@ void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p)
 
 
 	{
-		std::unique_lock<std::mutex> lock(priv->bufferMutex);
+		AppenderScopedLock lock(priv->bufferMutex);
 
 		while (true)
 		{
@@ -286,7 +276,7 @@ void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p)
 void AsyncAppender::close()
 {
 	{
-		std::lock_guard<std::mutex> lock(priv->bufferMutex);
+		AppenderScopeGuard lock(priv->bufferMutex);
 		priv->closed = true;
 		priv->bufferNotEmpty.notify_all();
 		priv->bufferNotFull.notify_all();
@@ -298,13 +288,9 @@ void AsyncAppender::close()
 	}
 
 	{
-		AppenderList appenderList = priv->appenders->getAllAppenders();
-
-		for (AppenderList::iterator iter = appenderList.begin();
-			iter != appenderList.end();
-			iter++)
+		for (auto item : priv->appenders->getAllAppenders())
 		{
-			(*iter)->close();
+			item->close();
 		}
 	}
 }
@@ -362,7 +348,7 @@ void AsyncAppender::setBufferSize(int size)
 		throw IllegalArgumentException(LOG4CXX_STR("size argument must be non-negative"));
 	}
 
-	std::lock_guard<std::mutex> lock(priv->bufferMutex);
+	AppenderScopeGuard lock(priv->bufferMutex);
 	priv->bufferSize = (size < 1) ? 1 : size;
 	priv->bufferNotFull.notify_all();
 }
@@ -374,7 +360,7 @@ int AsyncAppender::getBufferSize() const
 
 void AsyncAppender::setBlocking(bool value)
 {
-	std::lock_guard<std::mutex> lock(priv->bufferMutex);
+	AppenderScopeGuard lock(priv->bufferMutex);
 	priv->blocking = value;
 	priv->bufferNotFull.notify_all();
 }
@@ -451,7 +437,7 @@ void AsyncAppender::dispatch()
 		Pool p;
 		LoggingEventList events;
 		{
-			std::unique_lock<std::mutex> lock(priv->bufferMutex);
+			AppenderScopedLock lock(priv->bufferMutex);
 			priv->bufferNotEmpty.wait(lock, [this]() -> bool
 				{ return 0 < priv->buffer.size() || priv->closed; }
 			);
diff --git a/src/main/cpp/fileappender.cpp b/src/main/cpp/fileappender.cpp
index 38814855..f4134753 100644
--- a/src/main/cpp/fileappender.cpp
+++ b/src/main/cpp/fileappender.cpp
@@ -85,13 +85,13 @@ FileAppender::~FileAppender()
 
 void FileAppender::setAppend(bool fileAppend1)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	_priv->fileAppend = fileAppend1;
 }
 
 void FileAppender::setFile(const LogString& file)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	setFileInternal(file);
 }
 
@@ -102,7 +102,7 @@ void FileAppender::setFileInternal(const LogString& file)
 
 void FileAppender::setBufferedIO(bool bufferedIO1)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	_priv->bufferedIO = bufferedIO1;
 
 	if (bufferedIO1)
@@ -117,27 +117,27 @@ void FileAppender::setOption(const LogString& option,
 	if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("FILE"), LOG4CXX_STR("file"))
 		|| StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("FILENAME"), LOG4CXX_STR("filename")))
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->fileName = stripDuplicateBackslashes(value);
 	}
 	else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("APPEND"), LOG4CXX_STR("append")))
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->fileAppend = OptionConverter::toBoolean(value, true);
 	}
 	else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BUFFEREDIO"), LOG4CXX_STR("bufferedio")))
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->bufferedIO = OptionConverter::toBoolean(value, true);
 	}
 	else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("IMMEDIATEFLUSH"), LOG4CXX_STR("immediateflush")))
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->bufferedIO = !OptionConverter::toBoolean(value, false);
 	}
 	else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BUFFERSIZE"), LOG4CXX_STR("buffersize")))
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->bufferSize = OptionConverter::toFileSize(value, 8 * 1024);
 	}
 	else
@@ -148,7 +148,7 @@ void FileAppender::setOption(const LogString& option,
 
 void FileAppender::activateOptions(Pool& p)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	activateOptionsInternal(p);
 }
 
diff --git a/src/main/cpp/multiprocessrollingfileappender.cpp b/src/main/cpp/multiprocessrollingfileappender.cpp
index 29b02592..8224b1bb 100644
--- a/src/main/cpp/multiprocessrollingfileappender.cpp
+++ b/src/main/cpp/multiprocessrollingfileappender.cpp
@@ -114,7 +114,7 @@ void MultiprocessRollingFileAppender::activateOptions(Pool& p)
 	}
 
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->triggeringPolicy->activateOptions(p);
 		_priv->rollingPolicy->activateOptions(p);
 
@@ -202,7 +202,7 @@ void MultiprocessRollingFileAppender::releaseFileLock(apr_file_t* lock_file)
  */
 bool MultiprocessRollingFileAppender::rollover(Pool& p)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	return rolloverInternal(p);
 }
 
diff --git a/src/main/cpp/rollingfileappender.cpp b/src/main/cpp/rollingfileappender.cpp
index df553777..b2c00fe7 100644
--- a/src/main/cpp/rollingfileappender.cpp
+++ b/src/main/cpp/rollingfileappender.cpp
@@ -229,7 +229,7 @@ void RollingFileAppender::activateOptions(Pool& p)
 	}
 
 	{
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 		_priv->triggeringPolicy->activateOptions(p);
 		_priv->rollingPolicy->activateOptions(p);
 
@@ -301,7 +301,7 @@ void RollingFileAppender::activateOptions(Pool& p)
  */
 bool RollingFileAppender::rollover(Pool& p)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	return rolloverInternal(p);
 }
 
diff --git a/src/main/cpp/socketappenderskeleton.cpp b/src/main/cpp/socketappenderskeleton.cpp
index 9f0117fa..8a4a4b0b 100644
--- a/src/main/cpp/socketappenderskeleton.cpp
+++ b/src/main/cpp/socketappenderskeleton.cpp
@@ -68,7 +68,7 @@ void SocketAppenderSkeleton::activateOptions(Pool& p)
 
 void SocketAppenderSkeleton::close()
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 
 	if (_priv->closed)
 	{
@@ -147,7 +147,7 @@ void SocketAppenderSkeleton::setOption(const LogString& option, const LogString&
 
 void SocketAppenderSkeleton::fireConnector()
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 
 	if ( !_priv->thread.joinable() )
 	{
diff --git a/src/main/cpp/telnetappender.cpp b/src/main/cpp/telnetappender.cpp
index 0c72a809..af1695f0 100644
--- a/src/main/cpp/telnetappender.cpp
+++ b/src/main/cpp/telnetappender.cpp
@@ -101,13 +101,13 @@ void TelnetAppender::setOption(const LogString& option,
 
 LogString TelnetAppender::getEncoding() const
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	return _priv->encoding;
 }
 
 void TelnetAppender::setEncoding(const LogString& value)
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	_priv->encoder = CharsetEncoder::getEncoder(value);
 	_priv->encoding = value;
 }
@@ -115,7 +115,7 @@ void TelnetAppender::setEncoding(const LogString& value)
 
 void TelnetAppender::close()
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 
 	if (_priv->closed)
 	{
@@ -212,7 +212,7 @@ void TelnetAppender::append(const spi::LoggingEventPtr& event, Pool& p)
 		LogString::const_iterator msgIter(msg.begin());
 		ByteBuffer buf(bytes, bytesSize);
 
-		std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+		AppenderScopeGuard lock(_priv->mutex);
 
 		while (msgIter != msg.end())
 		{
@@ -268,7 +268,7 @@ void TelnetAppender::acceptConnections()
 				//
 				//   find unoccupied connection
 				//
-				std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+				AppenderScopeGuard lock(_priv->mutex);
 
 				for (ConnectionList::iterator iter = _priv->connections.begin();
 					iter != _priv->connections.end();
diff --git a/src/main/cpp/writerappender.cpp b/src/main/cpp/writerappender.cpp
index ada3bd89..475c0268 100644
--- a/src/main/cpp/writerappender.cpp
+++ b/src/main/cpp/writerappender.cpp
@@ -158,7 +158,7 @@ bool WriterAppender::checkEntryConditions() const
    */
 void WriterAppender::close()
 {
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 
 	if (_priv->closed)
 	{
@@ -285,7 +285,7 @@ void WriterAppender::writeHeader(Pool& p)
 
 void WriterAppender::setWriter(const WriterPtr& newWriter)
 {
-	std::unique_lock<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	setWriterInternal(newWriter);
 }
 
diff --git a/src/main/cpp/xmlsocketappender.cpp b/src/main/cpp/xmlsocketappender.cpp
index 594b5905..9f839068 100644
--- a/src/main/cpp/xmlsocketappender.cpp
+++ b/src/main/cpp/xmlsocketappender.cpp
@@ -102,7 +102,7 @@ void XMLSocketAppender::setSocket(log4cxx::helpers::SocketPtr& socket, Pool& p)
 {
 	OutputStreamPtr os = std::make_shared<SocketOutputStream>(socket);
 	CharsetEncoderPtr charset(CharsetEncoder::getUTF8Encoder());
-	std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
+	AppenderScopeGuard lock(_priv->mutex);
 	_priv->writer = std::make_shared<OutputStreamWriter>(os, charset);
 }
 
diff --git a/src/main/include/CMakeLists.txt b/src/main/include/CMakeLists.txt
index 205041da..ded2c6d7 100644
--- a/src/main/include/CMakeLists.txt
+++ b/src/main/include/CMakeLists.txt
@@ -123,24 +123,8 @@ CHECK_FUNCTION_EXISTS(wcstombs HAS_WCSTOMBS)
 CHECK_FUNCTION_EXISTS(fwide HAS_FWIDE)
 CHECK_LIBRARY_EXISTS(esmtp smtp_create_session "" HAS_LIBESMTP)
 CHECK_FUNCTION_EXISTS(syslog HAS_SYSLOG)
-if(UNIX)
-    set(CMAKE_REQUIRED_LIBRARIES "pthread")
-    CHECK_SYMBOL_EXISTS(pthread_sigmask "signal.h" HAS_PTHREAD_SIGMASK)
-
-    # Check for the (linux) pthread_setname_np.
-    # OSX and BSD are special apparently.  OSX only lets you name
-    # the current thread, while BSD calls it pthread_set_name_np.
-    # Since this is really not a core feature and the end-user can configure
-    # it anyway, we're only going to worry about linux.
-    include(${LOG4CXX_SOURCE_DIR}/src/cmake/pthread/log4cxx-pthread.cmake)
-    if(${PTHREAD_SETNAME_NP_FOUND})
-	set(HAS_PTHREAD_SETNAME 1)
-    endif()
-    if(${PTHREAD_GETNAME_NP_FOUND})
-	set(HAS_PTHREAD_GETNAME 1)
-    endif()
-endif(UNIX)
 
+# Ensure log4cxx_private.h.in configurable variables are either 0 or 1
 foreach(varName
   HAS_THREAD_LOCAL
   HAS_STD_LOCALE
@@ -153,6 +137,7 @@ foreach(varName
   HAS_PTHREAD_SIGMASK
   HAS_PTHREAD_SETNAME
   HAS_PTHREAD_GETNAME
+  HAS_PTHREAD_SETPROTOCOL
   )
   if(${varName} EQUAL 0)
     continue()
diff --git a/src/main/include/log4cxx/appenderskeleton.h b/src/main/include/log4cxx/appenderskeleton.h
index f91545e2..b7495a70 100644
--- a/src/main/include/log4cxx/appenderskeleton.h
+++ b/src/main/include/log4cxx/appenderskeleton.h
@@ -50,6 +50,11 @@ class LOG4CXX_EXPORT AppenderSkeleton :
 		*/
 		virtual void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p) = 0;
 
+		/**
+		* Allow one thread at a time to check filters before passing \c event to AppenderSkeleton#append.
+		*
+		* The sub-class AppenderSkeleton#append method is responsible for the actual output.
+		*/
 		void doAppendImpl(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& pool);
 
 	public:
@@ -130,12 +135,11 @@ class LOG4CXX_EXPORT AppenderSkeleton :
 		*/
 		bool isAsSevereAsThreshold(const LevelPtr& level) const;
 
-
 		/**
-		* This method performs threshold checks and invokes filters before
-		* delegating actual logging to the subclasses specific
-		* AppenderSkeleton#append method.
-		* */
+		* Allow one thread at a time to check filters before passing \c event to AppenderSkeleton#append.
+		*
+		* The sub-class AppenderSkeleton#append method is responsible for the actual output.
+		*/
 		void doAppend(const spi::LoggingEventPtr& event, helpers::Pool& pool) override;
 
 		/**
diff --git a/src/main/include/log4cxx/private/appenderskeleton_priv.h b/src/main/include/log4cxx/private/appenderskeleton_priv.h
index 67b271f3..5edfcc5c 100644
--- a/src/main/include/log4cxx/private/appenderskeleton_priv.h
+++ b/src/main/include/log4cxx/private/appenderskeleton_priv.h
@@ -20,6 +20,7 @@
 
 #include <log4cxx/appenderskeleton.h>
 #include <log4cxx/helpers/onlyonceerrorhandler.h>
+#include <log4cxx/private/mutex.h>
 #include <memory>
 
 namespace log4cxx
@@ -27,16 +28,12 @@ namespace log4cxx
 
 struct AppenderSkeleton::AppenderSkeletonPrivate
 {
-	AppenderSkeletonPrivate() :
-		threshold(Level::getAll()),
-		errorHandler(std::make_shared<log4cxx::helpers::OnlyOnceErrorHandler>()),
-		closed(false) {}
-
-	AppenderSkeletonPrivate( LayoutPtr lay ) :
+	AppenderSkeletonPrivate( LayoutPtr lay = LayoutPtr() ) :
 		layout( lay ),
 		threshold(Level::getAll()),
-		errorHandler(std::make_shared<log4cxx::helpers::OnlyOnceErrorHandler>()),
-		closed(false) {}
+		errorHandler(std::make_shared<helpers::OnlyOnceErrorHandler>()),
+		closed(false)
+		{ EnablePriorityInheritance(mutex, pool); }
 
 	virtual ~AppenderSkeletonPrivate(){}
 
@@ -68,8 +65,9 @@ struct AppenderSkeleton::AppenderSkeletonPrivate
 	*/
 	bool closed;
 
-	log4cxx::helpers::Pool pool;
-	mutable std::recursive_mutex mutex;
+	helpers::Pool pool;
+
+	mutable AppenderMutexType mutex;
 };
 
 }
diff --git a/src/main/include/log4cxx/private/log4cxx_private.h.in b/src/main/include/log4cxx/private/log4cxx_private.h.in
index 61e8e7ac..7b158f45 100644
--- a/src/main/include/log4cxx/private/log4cxx_private.h.in
+++ b/src/main/include/log4cxx/private/log4cxx_private.h.in
@@ -60,6 +60,7 @@
 #define LOG4CXX_HAS_PTHREAD_SIGMASK @HAS_PTHREAD_SIGMASK@
 #define LOG4CXX_HAS_PTHREAD_SETNAME @HAS_PTHREAD_SETNAME@
 #define LOG4CXX_HAS_PTHREAD_GETNAME @HAS_PTHREAD_GETNAME@
+#define LOG4CXX_HAS_PTHREAD_SETPROTOCOL @HAS_PTHREAD_SETPROTOCOL@
 #define LOG4CXX_HAS_THREAD_LOCAL @HAS_THREAD_LOCAL@
 
 #endif
diff --git a/src/main/include/log4cxx/private/mutex.h b/src/main/include/log4cxx/private/mutex.h
new file mode 100644
index 00000000..6993f57d
--- /dev/null
+++ b/src/main/include/log4cxx/private/mutex.h
@@ -0,0 +1,72 @@
+/*
+ * 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.
+ */
+
+#ifndef LOG4CXX_PRIV_MUTEX_HDR_
+#define LOG4CXX_PRIV_MUTEX_HDR_
+#include <mutex>
+#include <log4cxx/helpers/loglog.h>
+#include <log4cxx/helpers/stringhelper.h>
+#if !defined(LOG4CXX)
+	#define LOG4CXX 1
+#endif
+#include <log4cxx/private/log4cxx_private.h>
+
+namespace log4cxx
+{
+
+using AppenderMutexType = std::mutex;
+using AppenderScopeGuard = std::lock_guard<AppenderMutexType>;
+using AppenderScopedLock = std::unique_lock<AppenderMutexType>;
+
+// Change mutex attributes to avoid priority inversion problems
+template <class M>
+	void
+EnablePriorityInheritance(M& m, helpers::Pool& p)
+{
+#if LOG4CXX_HAS_PTHREAD_SETPROTOCOL
+	pthread_mutexattr_t rrAttr;
+	if (pthread_mutexattr_init(&rrAttr) != 0)
+	{
+		LogString msg = LOG4CXX_STR("pthread_mutexattr_init error ");
+		helpers::toString(errno, p, msg)
+		helpers::LogLog::warn(msg);
+	}
+	else if (pthread_mutexattr_setprotocol(&rrAttr, PTHREAD_PRIO_INHERIT) != 0)
+	{
+		LogString msg = LOG4CXX_STR("pthread_mutexattr_setprotocol error ");
+		helpers::toString(errno, p, msg)
+		helpers::LogLog::warn(msg);
+	}
+	else if (pthread_mutex_destroy(m.native_handle()) != 0)
+	{
+		LogString msg = LOG4CXX_STR("pthread_mutex_destroy error ");
+		helpers::toString(errno, p, msg)
+		helpers::LogLog::warn(msg);
+	}
+	else if (pthread_mutex_init(m.native_handle(), &rrAttr) != 0)
+	{
+		LogString msg = LOG4CXX_STR("pthread_mutex_init error ");
+		helpers::toString(errno, p, msg)
+		helpers::LogLog::warn(msg);
+	}
+	pthread_mutexattr_destroy(&rrAttr);
+#endif // LOG4CXX_HAS_PTHREAD_SETPROTOCOL
+}
+
+} // namespace log4cxx
+
+#endif /* LOG4CXX_PRIV_MUTEX_HDR_ */