Re: [Boost-users] Example of using a mutex a lock

From: Leon Mlakar (leon.mlakar_at_[hidden])
Date: 2007-05-07 04:30:47

Use:

      {         // lock the resource
          boost::recursive_mutex::scoped_lock(m_mutex);       

              ... do your stuff here ...

      }         // unlock the resource

In the static functions use boost::scoped_lock(m_instance->m_mutex);

Note the placement of braces - they create a scope block within which the
scoped_lock object exists. The scoped_lock will lock the mutex in its
constructor and unlock it its in desctructor. See also the rationalo for
lock desig in Tread library documentation.

Leon

> -----Original Message-----
> From: boost-users-bounces_at_[hidden] 
> [mailto:boost-users-bounces_at_[hidden]] On Behalf Of 
> Stephen Torri
> Sent: Friday, May 04, 2007 8:51 PM
> To: boost-users
> Subject: [Boost-users] Example of using a mutex a lock
> 
> I am trying to create a class for performing log tracing. 
> While my present program is single threaded as far as my code 
> is concerned this may not always be the case. Below is the 
> code that I am proposing to use. What I am weak on is 
> concurrent programming. I know that I need to use a mutex but 
> I am not sure how to use the boost thread mutex library and 
> locks. Can someone comment on how I can modify the 
> Trace_State class to use locking?
> 
> Stephen
> 
> ----------------
> #include <boost/cstdint.hpp>
> #include <boost/shared_ptr.hpp>
> #include <fstream>
> #include <boost/date_time/posix_time/posix_time.hpp>
> #include <sstream>
> #include <boost/format.hpp>
> 
> namespace libreverse { namespace trace {
> 
>     /* Idea taken from http://www.codeproject.com/debug/xytrace.asp
>      * (28 Jan 2002 - Xiangyang Liu)
>      *
>      * I have modified this so that we don't use varargs and 
> use constant types
>      */
>     class TraceLevel {
>     public:
>         static boost::uint32_t TraceNone;   // No trace
>         static boost::uint32_t TraceError;  // Only trace error
>         static boost::uint32_t TraceInfo;   // Some extra information
>         static boost::uint32_t TraceDebug;  // Debugging information
>         static boost::uint32_t TraceDetail; // Detailed 
> debugging information
>     };
> 
>     boost::uint32_t TraceLevel::TraceNone = 0;
>     boost::uint32_t TraceLevel::TraceError = 10;
>     boost::uint32_t TraceLevel::TraceInfo = 20;
>     boost::uint32_t TraceLevel::TraceDebug = 30;
>     boost::uint32_t TraceLevel::TraceDetail = 40;
> 
>     class Trace_State {
>     public:
> 
>         typedef boost::shared_ptr<Trace_State> ptr_t;
> 
>         static Trace_State::ptr_t Instance()
>         {
>             // Lock the resource?
>             if ( m_instance.get() == 0 )
>                 {
>                     m_instance = Trace_State::ptr_t ( new
> Trace_State() );
>                 }
> 
>             // Unlock the resource?
> 
>             return m_instance;
>         }
> 
>         void set_Trace_File_Prefix ( std::string name )
>         {
>             assert ( ! name.empty() );
> 
>             // Lock the resource
>             // Close the present file
>             m_file_prefix = name;
>             // Unlock the resource
>         }
> 
>         void set_Trace_Level ( boost::uint32_t level )
>         {            
>             // Lock the resource
>             // Change level
>             m_trace_level = level;
>             // Unlock the resource
>         }
> 
>         void open_Trace_File ( void )
>         {
>             // Create file name
>             std::stringstream name;
> 
>             // Get current time
>             boost::posix_time::ptime now =
>                 boost::posix_time::second_clock::local_time();
>             std::tm tm_ref = boost::posix_time::to_tm ( now );
> 
>             boost::gregorian::date today = now.date();
> 
>             name << boost::format ( "%s_%s_%02d:%02d:%02d.txt" )
>                 % m_file_prefix
>                 % boost::gregorian::to_iso_extended_string ( today )
>                 % tm_ref.tm_hour
>                 % tm_ref.tm_min
>                 % tm_ref.tm_sec;
> 
>             m_log_stream.open ( (name.str()).c_str() );
> 
>         }
> 
>         void close_Trace_File ( void )
>         {
>             m_log_stream.close();
>         }
> 
>         boost::uint32_t get_Trace_Level ( void ) const
>         {
>             boost::uint32_t level = 0;
> 
>             // Lock the resource
> 
>             // get the level
>             level = m_trace_level;
> 
>             // unlock the resource
> 
>             // return the level
>             return level;
>         }
> 
>         void write_Message ( std::string msg )
>         {
>             // Lock the resource
>             
>             // Write to the file
>             m_log_stream << msg;
> 
>             // Unlock the resource
>         }
> 
>     private:
> 
>         Trace_State()
>             : m_file_prefix ( "Trace" ),
>               m_trace_level ( TraceLevel::TraceNone )
>         {}
> 
>         static Trace_State::ptr_t m_instance;
>         
>         std::string m_file_prefix;
> 
>         boost::uint32_t m_trace_level;
> 
>         //boost::recursive_mutex m_mutex;
> 
>         std::ofstream m_log_stream;
>     };
> 
>     Trace_State::ptr_t Trace_State::m_instance;
> 
>     class Trace {
>     public:
> 
>         static void write_Trace ( boost::uint32_t level,
>                                   std::string message )
>         {
>             Trace_State::ptr_t state_ptr = Trace_State::Instance();
> 
>             // If the level is equal to or greater than the present
>             // level we record out message.
>             if ( level >= state_ptr->get_Trace_Level() )
>                 {
>                     state_ptr->write_Message ( message );
>                 }
>         }
>     };
> 
> 
> } /* namespace trace */
> } /* namespace trace */
> 
> int main (int, char**)
> {
>     libreverse::trace::Trace_State::ptr_t state_ptr =
>         libreverse::trace::Trace_State::Instance();
> 
>     state_ptr->set_Trace_File_Prefix ("Funky");
>     state_ptr->open_Trace_File();
>     state_ptr->close_Trace_File();
>     return 0;
> }
> 
> 
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users
>