CODEWITHSUNDEEP
c++design-patternssingletonlogging
shiouming
shiouming

Reputation: 1949

Simple C++ logger by using singleton pattern

Due to the flooding examples of implementing logger using Singleton pattern, I have just written a simple C++ logger in the same approach for my program. However, since the famous double-checked locking approach is known to be no more thread-safe, I wonder if I should:

1) Forget about the use of Singleton pattern in this case?

2) Continue to use double-checked locking even though it is unsafe?

3) Use the expensive pure sync lock method for every access to its public interfaces?

Any suggestions?

Upvotes: 7

Views: 12200

Answers (4)

BostonLogan
BostonLogan

Reputation: 1596

You do not really need separate Initialize() function as this will just contaminate your singleton interface. Just get singleton instance 

VERIFY(NULL != Logger::Instance());

before any other thread has chance to access it.

Upvotes: 0

Arkaitz Jimenez
Arkaitz Jimenez

Reputation: 23198

Use Meyers Singleton. If you are using using gcc at least initialization is thread-safe.

class Singleton{
   Singleton(){
    //This is threadsafe in gcc, no mutex required
   }
   static Singleton * instance(){
      static Singleton myinstance;
      return &myinstance;
   }
};

gcc guards static locals construction unless you disable with -fno-threadsafe-statics, I recently wrote about that here

Upvotes: 17

Michael Kohne
Michael Kohne

Reputation: 12044

One approach would be to make sure that your first access to the logger comes before your app starts a second thread. By accessing the singleton at a time when you KNOW that there isn't any contention, you make sure that subsequent accesses will always find a pre-existing object and you should completely avoid the problem.

Upvotes: 1

stefaanv
stefaanv

Reputation: 14392

In applications with threads, I prefer to use singletons with an initialize() function and asserts to make sure that the initialize() is used before the first instance(). Call initialize() from the main thread. I don't think that lazy instantiation is really the key feature of a singleton, especially for a logger.

While Arkaitz's answer is more elegant, my answers avoids threading issues on all platforms with the cost of 1 extra function and some instantiating concerns during startup for singletons with dependencees (helped by asserts and ofcourse: use singletons judiciously).

Upvotes: 1

Related Questions