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

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


The following commit(s) were added to refs/heads/master by this push:
     new 57295d26 Prefer std::lock_guard when std::unique_lock features are not 
required (#369)
57295d26 is described below

commit 57295d2630c051c93a0fe9894958eca4b5557482
Author: Stephen Webb <[email protected]>
AuthorDate: Tue Apr 23 12:13:57 2024 +1000

    Prefer std::lock_guard when std::unique_lock features are not required 
(#369)
---
 src/main/cpp/action.cpp                         |  4 ++--
 src/main/cpp/aprinitializer.cpp                 | 12 ++++++------
 src/main/cpp/aprserversocket.cpp                |  4 ++--
 src/main/cpp/asyncappender.cpp                  |  2 +-
 src/main/cpp/charsetdecoder.cpp                 |  4 ++--
 src/main/cpp/charsetencoder.cpp                 |  4 ++--
 src/main/cpp/filewatchdog.cpp                   |  6 +-----
 src/main/cpp/hierarchy.cpp                      |  4 ++--
 src/main/cpp/loglog.cpp                         | 16 ++++++++--------
 src/main/cpp/socketappenderskeleton.cpp         |  7 +------
 src/main/cpp/writerappender.cpp                 |  2 +-
 src/test/cpp/asyncappendertestcase.cpp          |  4 ++--
 src/test/cpp/helpers/charsetencodertestcase.cpp |  1 -
 src/test/cpp/throughput/throughput-main.cpp     |  4 ++--
 14 files changed, 32 insertions(+), 42 deletions(-)

diff --git a/src/main/cpp/action.cpp b/src/main/cpp/action.cpp
index 6072cfb2..ccc31d4a 100644
--- a/src/main/cpp/action.cpp
+++ b/src/main/cpp/action.cpp
@@ -43,7 +43,7 @@ Action::~Action()
  */
 void Action::run(LOG4CXX_NS::helpers::Pool& pool1)
 {
-       std::unique_lock<std::mutex> lock(m_priv->mutex);
+       std::lock_guard<std::mutex> lock(m_priv->mutex);
 
        if (!m_priv->interrupted)
        {
@@ -66,7 +66,7 @@ void Action::run(LOG4CXX_NS::helpers::Pool& pool1)
  */
 void Action::close()
 {
-       std::unique_lock<std::mutex> lock(m_priv->mutex);
+       std::lock_guard<std::mutex> lock(m_priv->mutex);
        m_priv->interrupted = true;
 }
 
diff --git a/src/main/cpp/aprinitializer.cpp b/src/main/cpp/aprinitializer.cpp
index 6dbf01dd..135f696a 100644
--- a/src/main/cpp/aprinitializer.cpp
+++ b/src/main/cpp/aprinitializer.cpp
@@ -98,14 +98,14 @@ APRInitializer::~APRInitializer()
        stopWatchDogs();
        isDestructed = true;
 #if APR_HAS_THREADS
-       std::unique_lock<std::mutex> lock(m_priv->mutex);
+       std::lock_guard<std::mutex> lock(m_priv->mutex);
        apr_threadkey_private_delete(m_priv->tlsKey);
 #endif
 }
 
 void APRInitializer::stopWatchDogs()
 {
-       std::unique_lock<std::mutex> lock(m_priv->mutex);
+       std::lock_guard<std::mutex> lock(m_priv->mutex);
 
        while (!m_priv->watchdogs.empty())
        {
@@ -146,14 +146,14 @@ apr_threadkey_t* APRInitializer::getTlsKey()
 void APRInitializer::registerCleanup(FileWatchdog* watchdog)
 {
        APRInitializer& instance(getInstance());
-       std::unique_lock<std::mutex> lock(instance.m_priv->mutex);
+       std::lock_guard<std::mutex> lock(instance.m_priv->mutex);
        instance.m_priv->watchdogs.push_back(watchdog);
 }
 
 void APRInitializer::unregisterCleanup(FileWatchdog* watchdog)
 {
        APRInitializer& instance(getInstance());
-       std::unique_lock<std::mutex> lock(instance.m_priv->mutex);
+       std::lock_guard<std::mutex> lock(instance.m_priv->mutex);
 
        auto iter = std::find(instance.m_priv->watchdogs.begin(), 
instance.m_priv->watchdogs.end(), watchdog);
        if (iter != instance.m_priv->watchdogs.end())
@@ -162,13 +162,13 @@ void APRInitializer::unregisterCleanup(FileWatchdog* 
watchdog)
 
 void APRInitializer::addObject(size_t key, const ObjectPtr& pObject)
 {
-       std::unique_lock<std::mutex> lock(m_priv->mutex);
+       std::lock_guard<std::mutex> lock(m_priv->mutex);
        m_priv->objects[key] = pObject;
 }
 
 const ObjectPtr& APRInitializer::findOrAddObject(size_t key, 
std::function<ObjectPtr()> creator)
 {
-       std::unique_lock<std::mutex> lock(m_priv->mutex);
+       std::lock_guard<std::mutex> lock(m_priv->mutex);
        auto pItem = m_priv->objects.find(key);
        if (m_priv->objects.end() == pItem)
                pItem = m_priv->objects.emplace(key, creator()).first;
diff --git a/src/main/cpp/aprserversocket.cpp b/src/main/cpp/aprserversocket.cpp
index d92a7a3f..080a6a29 100644
--- a/src/main/cpp/aprserversocket.cpp
+++ b/src/main/cpp/aprserversocket.cpp
@@ -82,7 +82,7 @@ APRServerSocket::APRServerSocket(int port) :
 }
 
 void APRServerSocket::close(){
-       std::unique_lock<std::mutex> lock(_priv->mutex);
+       std::lock_guard<std::mutex> lock(_priv->mutex);
 
        if (_priv->socket != 0)
        {
@@ -103,7 +103,7 @@ accepts it
 */
 SocketPtr APRServerSocket::accept()
 {
-       std::unique_lock<std::mutex> lock(_priv->mutex);
+       std::lock_guard<std::mutex> lock(_priv->mutex);
 
        if (_priv->socket == 0)
        {
diff --git a/src/main/cpp/asyncappender.cpp b/src/main/cpp/asyncappender.cpp
index 332ba533..ba35245a 100644
--- a/src/main/cpp/asyncappender.cpp
+++ b/src/main/cpp/asyncappender.cpp
@@ -257,7 +257,7 @@ void AsyncAppender::append(const spi::LoggingEventPtr& 
event, Pool& p)
 
        if (!priv->dispatcher.joinable())
        {
-               std::unique_lock<std::mutex> lock(priv->bufferMutex);
+               std::lock_guard<std::mutex> lock(priv->bufferMutex);
                if (!priv->dispatcher.joinable())
                        priv->dispatcher = 
ThreadUtility::instance()->createThread( LOG4CXX_STR("AsyncAppender"), 
&AsyncAppender::dispatch, this );
        }
diff --git a/src/main/cpp/charsetdecoder.cpp b/src/main/cpp/charsetdecoder.cpp
index 943da63d..b985f475 100644
--- a/src/main/cpp/charsetdecoder.cpp
+++ b/src/main/cpp/charsetdecoder.cpp
@@ -98,7 +98,7 @@ class APRCharsetDecoder : public CharsetDecoder
                        {
                                size_t outbytes_left = initial_outbytes_left;
                                {
-                                       std::unique_lock<std::mutex> 
lock(mutex);
+                                       std::lock_guard<std::mutex> lock(mutex);
                                        stat = 
apr_xlate_conv_buffer((apr_xlate_t*) convset,
                                                        NULL, NULL, (char*) 
buf, &outbytes_left);
                                }
@@ -113,7 +113,7 @@ class APRCharsetDecoder : public CharsetDecoder
                                        size_t pos = in.position();
                                        apr_size_t outbytes_left = 
initial_outbytes_left;
                                        {
-                                               std::unique_lock<std::mutex> 
lock(mutex);
+                                               std::lock_guard<std::mutex> 
lock(mutex);
                                                stat = 
apr_xlate_conv_buffer((apr_xlate_t*) convset,
                                                                in.data() + pos,
                                                                &inbytes_left,
diff --git a/src/main/cpp/charsetencoder.cpp b/src/main/cpp/charsetencoder.cpp
index ec39aec3..b08e277b 100644
--- a/src/main/cpp/charsetencoder.cpp
+++ b/src/main/cpp/charsetencoder.cpp
@@ -91,7 +91,7 @@ class APRCharsetEncoder : public CharsetEncoder
 
                        if (iter == in.end())
                        {
-                               std::unique_lock<std::mutex> lock(mutex);
+                               std::lock_guard<std::mutex> lock(mutex);
                                stat = apr_xlate_conv_buffer(convset, NULL, 
NULL,
                                                out.data() + position, 
&outbytes_left);
                        }
@@ -102,7 +102,7 @@ class APRCharsetEncoder : public CharsetEncoder
                                        (in.size() - inOffset) * 
sizeof(LogString::value_type);
                                apr_size_t initial_inbytes_left = inbytes_left;
                                {
-                                       std::unique_lock<std::mutex> 
lock(mutex);
+                                       std::lock_guard<std::mutex> lock(mutex);
                                        stat = apr_xlate_conv_buffer(convset,
                                                        (const char*) 
(in.data() + inOffset),
                                                        &inbytes_left,
diff --git a/src/main/cpp/filewatchdog.cpp b/src/main/cpp/filewatchdog.cpp
index c31363b0..e51c5931 100644
--- a/src/main/cpp/filewatchdog.cpp
+++ b/src/main/cpp/filewatchdog.cpp
@@ -74,11 +74,7 @@ void FileWatchdog::stop()
 {
        LogLog::debug(LOG4CXX_STR("Stopping file watchdog"));
        m_priv->interrupted = 0xFFFF;
-
-       {
-               std::unique_lock<std::mutex> lock(m_priv->interrupt_mutex);
-               m_priv->interrupt.notify_all();
-       }
+       m_priv->interrupt.notify_all();
        m_priv->thread.join();
 }
 
diff --git a/src/main/cpp/hierarchy.cpp b/src/main/cpp/hierarchy.cpp
index b54c1976..7f780369 100644
--- a/src/main/cpp/hierarchy.cpp
+++ b/src/main/cpp/hierarchy.cpp
@@ -297,7 +297,7 @@ bool Hierarchy::isDisabled(int level) const
 
 void Hierarchy::ensureIsConfigured(std::function<void()> configurator)
 {
-       std::unique_lock<std::mutex> lock(m_priv->configuredMutex);
+       std::lock_guard<std::mutex> lock(m_priv->configuredMutex);
        if (!m_priv->configured)
        {
                configurator();
@@ -446,7 +446,7 @@ void Hierarchy::setConfigured(bool newValue)
 
 bool Hierarchy::isConfigured()
 {
-       std::unique_lock<std::mutex> lock(m_priv->configuredMutex); // Blocks 
while auto-configuration is active
+       std::lock_guard<std::mutex> lock(m_priv->configuredMutex); // Blocks 
while auto-configuration is active
        return m_priv->configured;
 }
 
diff --git a/src/main/cpp/loglog.cpp b/src/main/cpp/loglog.cpp
index 4b0a86cf..f9c58cdb 100644
--- a/src/main/cpp/loglog.cpp
+++ b/src/main/cpp/loglog.cpp
@@ -69,7 +69,7 @@ LogLog& LogLog::getInstance()
 void LogLog::setInternalDebugging(bool debugEnabled1)
 {
        auto p = getInstance().m_priv.get();
-       std::unique_lock<std::mutex> lock(p->mutex);
+       std::lock_guard<std::mutex> lock(p->mutex);
 
        p->debugEnabled = debugEnabled1;
 }
@@ -84,7 +84,7 @@ void LogLog::debug(const LogString& msg)
                        return;
                }
 
-               std::unique_lock<std::mutex> lock(p->mutex);
+               std::lock_guard<std::mutex> lock(p->mutex);
 
                emit(msg);
        }
@@ -98,7 +98,7 @@ void LogLog::debug(const LogString& msg, const 
std::exception& e)
                if (!p->debugEnabled)
                        return;
 
-               std::unique_lock<std::mutex> lock(p->mutex);
+               std::lock_guard<std::mutex> lock(p->mutex);
                emit(msg);
                emit(e);
        }
@@ -110,7 +110,7 @@ void LogLog::error(const LogString& msg)
        auto p = getInstance().m_priv.get();
        if (p && !p->quietMode) // Not deleted by onexit processing?
        {
-               std::unique_lock<std::mutex> lock(p->mutex);
+               std::lock_guard<std::mutex> lock(p->mutex);
 
                emit(msg);
        }
@@ -121,7 +121,7 @@ void LogLog::error(const LogString& msg, const 
std::exception& e)
        auto p = getInstance().m_priv.get();
        if (p && !p->quietMode) // Not deleted by onexit processing?
        {
-               std::unique_lock<std::mutex> lock(p->mutex);
+               std::lock_guard<std::mutex> lock(p->mutex);
                emit(msg);
                emit(e);
        }
@@ -130,7 +130,7 @@ void LogLog::error(const LogString& msg, const 
std::exception& e)
 void LogLog::setQuietMode(bool quietMode1)
 {
        auto p = getInstance().m_priv.get();
-       std::unique_lock<std::mutex> lock(p->mutex);
+       std::lock_guard<std::mutex> lock(p->mutex);
 
        p->quietMode = quietMode1;
 }
@@ -140,7 +140,7 @@ void LogLog::warn(const LogString& msg)
        auto p = getInstance().m_priv.get();
        if (p && !p->quietMode) // Not deleted by onexit processing?
        {
-               std::unique_lock<std::mutex> lock(p->mutex);
+               std::lock_guard<std::mutex> lock(p->mutex);
                emit(msg);
        }
 }
@@ -150,7 +150,7 @@ void LogLog::warn(const LogString& msg, const 
std::exception& e)
        auto p = getInstance().m_priv.get();
        if (p && !p->quietMode) // Not deleted by onexit processing?
        {
-               std::unique_lock<std::mutex> lock(p->mutex);
+               std::lock_guard<std::mutex> lock(p->mutex);
                emit(msg);
                emit(e);
        }
diff --git a/src/main/cpp/socketappenderskeleton.cpp 
b/src/main/cpp/socketappenderskeleton.cpp
index 677e811e..76f1a423 100644
--- a/src/main/cpp/socketappenderskeleton.cpp
+++ b/src/main/cpp/socketappenderskeleton.cpp
@@ -77,12 +77,7 @@ void SocketAppenderSkeleton::close()
 
        _priv->closed = true;
        cleanUp(_priv->pool);
-
-       {
-               std::unique_lock<std::mutex> lock2(_priv->interrupt_mutex);
-               _priv->interrupt.notify_all();
-       }
-
+       _priv->interrupt.notify_all();
        if ( _priv->thread.joinable() )
        {
                _priv->thread.join();
diff --git a/src/main/cpp/writerappender.cpp b/src/main/cpp/writerappender.cpp
index cce05df9..5751f255 100644
--- a/src/main/cpp/writerappender.cpp
+++ b/src/main/cpp/writerappender.cpp
@@ -290,7 +290,7 @@ void WriterAppender::writeHeader(Pool& p)
 
 void WriterAppender::setWriter(const WriterPtr& newWriter)
 {
-       std::unique_lock<std::recursive_mutex> lock(_priv->mutex);
+       std::lock_guard<std::recursive_mutex> lock(_priv->mutex);
        setWriterInternal(newWriter);
 }
 
diff --git a/src/test/cpp/asyncappendertestcase.cpp 
b/src/test/cpp/asyncappendertestcase.cpp
index 8a6fccc5..0b6cf794 100644
--- a/src/test/cpp/asyncappendertestcase.cpp
+++ b/src/test/cpp/asyncappendertestcase.cpp
@@ -84,7 +84,7 @@ class BlockableVectorAppender : public VectorAppender
                 */
                void append(const spi::LoggingEventPtr& event, 
log4cxx::helpers::Pool& p) override
                {
-                       std::unique_lock<std::mutex> lock( blocker );
+                       std::lock_guard<std::mutex> lock( blocker );
                        VectorAppender::append(event, p);
 
                        //
@@ -332,7 +332,7 @@ class AsyncAppenderTestCase : public 
AppenderSkeletonTestCase
                        LOG4CXX_INFO(rootLogger, "Hello, World"); // This 
causes the dispatch thread creation
                        std::this_thread::sleep_for( std::chrono::milliseconds( 
10 ) ); // Wait for the dispatch thread  to be ready
                        {
-                               std::unique_lock<std::mutex> 
sync(blockableAppender->getBlocker());
+                               std::lock_guard<std::mutex> 
sync(blockableAppender->getBlocker());
 
                                for (int i = 0; i < 140; i++)
                                {
diff --git a/src/test/cpp/helpers/charsetencodertestcase.cpp 
b/src/test/cpp/helpers/charsetencodertestcase.cpp
index 10c521de..0b86915a 100644
--- a/src/test/cpp/helpers/charsetencodertestcase.cpp
+++ b/src/test/cpp/helpers/charsetencodertestcase.cpp
@@ -251,7 +251,6 @@ public:
 
                        void signalAll()
                        {
-                               std::unique_lock<std::mutex> sync(lock);
                                condition.notify_all();
                        }
 
diff --git a/src/test/cpp/throughput/throughput-main.cpp 
b/src/test/cpp/throughput/throughput-main.cpp
index 6671c572..91bf7a7b 100644
--- a/src/test/cpp/throughput/throughput-main.cpp
+++ b/src/test/cpp/throughput/throughput-main.cpp
@@ -50,7 +50,7 @@ static void benchmark_function( const std::string& name, void 
(*fn)(int), int ho
        auto delta = high_resolution_clock::now() - start;
        auto delta_d = duration_cast<duration<double>>(delta).count();
 
-       std::unique_lock<std::mutex> lk(results_mutex);
+       std::lock_guard<std::mutex> lk(results_mutex);
        results.push_back( uint64_t(howmany / delta_d) );
        LOG4CXX_INFO_FMT( console, "Log4cxx {} Elapsed: {:.4} secs {:L}/sec",
                name,
@@ -73,7 +73,7 @@ static void benchmark_conversion_pattern( const std::string& 
name,
        auto delta = high_resolution_clock::now() - start;
        auto delta_d = duration_cast<duration<double>>(delta).count();
 
-       std::unique_lock<std::mutex> lk(results_mutex);
+       std::lock_guard<std::mutex> lk(results_mutex);
        results.push_back( uint64_t(howmany / delta_d) );
        LOG4CXX_INFO_FMT( console, "Log4cxx {} pattern: {} Elapsed: {:.4} secs 
{:L}/sec",
                name,

Reply via email to