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 2026/09/01 06:51:51 UTC
(logging-log4cxx) 01/01: Prevent potential data race when restarting the AsyncAppender dispatcher
This is an automated email from the ASF dual-hosted git repository.
swebb2066 pushed a commit to branch prevent_asyncappender_join_data_race
in repository https://gitbox.apache.org/repos/asf/logging-log4cxx.git
commit 80b4ea2e96fe0d6609442f71f37f1390ed07443c
Author: Stephen Webb <sw...@gmail.com>
AuthorDate: Tue Sep 1 16:49:14 2026 +1000
Prevent potential data race when restarting the AsyncAppender dispatcher
---
src/main/cpp/asyncappender.cpp | 74 +++++++++++++++++++++++++++++++-----------
1 file changed, 55 insertions(+), 19 deletions(-)
diff --git a/src/main/cpp/asyncappender.cpp b/src/main/cpp/asyncappender.cpp
index ef12808d..e7d7e6e7 100644
--- a/src/main/cpp/asyncappender.cpp
+++ b/src/main/cpp/asyncappender.cpp
@@ -196,10 +196,23 @@ struct AsyncAppender::AsyncAppenderPriv : public AppenderSkeleton::AppenderSkele
*/
std::thread dispatcher;
+ /**
+ * Serializes join()/joinable()/move-assignment on \c dispatcher:
+ * concurrent use of those operations on the same std::thread object
+ * is a data race with undefined behaviour.
+ */
+ std::mutex dispatcherMutex;
+
+ /**
+ * The dispatcher's thread id (written while holding \c dispatcherMutex,
+ * readable by logging threads without touching the thread object).
+ */
+ std::atomic<std::thread::id> dispatcherId{ std::thread::id() };
+
/**
* Used to determine when to restart dispatch thread.
*/
- bool dispatcherActive{ false };
+ std::atomic<bool> dispatcherActive{ false };
/**
* Used to determine whether to restart dispatch thread.
@@ -216,24 +229,32 @@ struct AsyncAppender::AsyncAppenderPriv : public AppenderSkeleton::AppenderSkele
*/
void checkDispatcher(const LogString& appenderName)
{
+ if (this->dispatcherActive) // Fast path: no lock while the dispatcher is running
+ return;
+
+ // A stopped (or not yet started) dispatcher may be observed by several
+ // logging threads concurrently; serialize all join()/joinable()/
+ // move-assignment on the thread object.
+ std::lock_guard<std::mutex> lock(this->dispatcherMutex);
+
// Restart dispatcher if it has stopped by an exception in an attached appender.
if (!this->dispatcherActive && this->dispatcher.joinable())
+ {
this->dispatcher.join();
+ this->dispatcherId = std::thread::id();
+ }
if (!this->dispatcher.joinable() && this->dispatcherStartCount <= 1)
{
- std::lock_guard<std::recursive_mutex> lock(this->mutex);
- if (!this->dispatcher.joinable())
- {
- ++this->dispatcherStartCount;
- this->dispatcherActive = true;
- this->dispatcher = ThreadUtility::instance()->createThread
- ( LOG4CXX_STR("AsyncAppender")
- , &AsyncAppender::AsyncAppenderPriv::dispatch
- , this
- , appenderName
- );
- }
+ ++this->dispatcherStartCount;
+ this->dispatcherActive = true;
+ this->dispatcher = ThreadUtility::instance()->createThread
+ ( LOG4CXX_STR("AsyncAppender")
+ , &AsyncAppender::AsyncAppenderPriv::dispatch
+ , this
+ , appenderName
+ );
+ this->dispatcherId = this->dispatcher.get_id();
}
}
@@ -242,9 +263,18 @@ struct AsyncAppender::AsyncAppenderPriv : public AppenderSkeleton::AppenderSkele
bufferNotEmpty.notify_all();
bufferNotFull.notify_all();
- if (dispatcher.joinable())
+ // Move the thread object out under the lock but join outside it:
+ // the exiting dispatcher may still need bufferMutex, and a thread
+ // blocked on dispatcherMutex may be holding bufferMutex.
+ std::thread stoppedDispatcher;
{
- dispatcher.join();
+ std::lock_guard<std::mutex> lock(dispatcherMutex);
+ stoppedDispatcher = std::move(dispatcher);
+ dispatcherId = std::thread::id();
+ }
+ if (stoppedDispatcher.joinable())
+ {
+ stoppedDispatcher.join();
}
}
@@ -359,7 +389,7 @@ void AsyncAppender::append( LOG4CXX_APPEND_FORMAL_PARAMETERS )
priv->checkDispatcher(getName());
- if (priv->dispatcher.get_id() == std::this_thread::get_id()) // From an appender attached to this?
+ if (priv->dispatcherId.load() == std::this_thread::get_id()) // From an appender attached to this?
{
std::unique_lock<std::mutex> lock(priv->bufferMutex);
auto loggerName = event->getLoggerName();
@@ -520,7 +550,9 @@ void AsyncAppender::setBufferSize(int size)
}
std::lock_guard<std::mutex> lock(priv->bufferMutex);
- if (priv->dispatcher.joinable())
+ // Use the atomic thread id (not the thread object) so no lock ordering
+ // with dispatcherMutex is needed here.
+ if (priv->dispatcherId.load() != std::thread::id())
{
throw RuntimeException(LOG4CXX_STR("AsyncAppender buffer size cannot be changed now"));
}
@@ -668,6 +700,12 @@ void AsyncAppender::AsyncAppenderPriv::dispatch(const LogString& appenderName)
this->discardMap.clear();
}
+ // A fault in an attached appender must not permanently disable this
+ // dispatch thread: producers using the default Blocking=true would
+ // hang forever once the ring buffer fills. Reset the failure budget
+ // for each batch so a transient fault (e.g. a temporarily full disk)
+ // only limits retries within the current batch.
+ failureCount = 0;
for (auto item : events)
{
try
@@ -690,8 +728,6 @@ void AsyncAppender::AsyncAppenderPriv::dispatch(const LogString& appenderName)
}
}
++iterationCount;
- if (1 < failureCount)
- break;
}
if (LogLog::isDebugEnabled())
{