Differences between static declarations in singletons

Question

(Code taken from book: http://gameprogrammingpatterns.com/ by Robert Nystrom)

In the book above the author comes with two different ways of making a singleton class:

First one:

class FileSystem
{
public:
  static FileSystem& instance()
  {
    // Lazy initialize.
    if (instance_ == NULL) instance_ = new FileSystem();
    return *instance_;
  }

private:
  FileSystem() {}

  static FileSystem* instance_;
};

And second one:

class FileSystem
{
public:
  static FileSystem& instance()
  {
    static FileSystem *instance = new FileSystem();
    return *instance;
  }

private:
  FileSystem() {}
};

Later he states that the second one is more proper way to do this, since it is thread safe, while the first one is not.
What makes the second one thread safe?
What is the difference in static declarations between these two?

score 3 · Accepted Answer · answered Apr 19 '15 at 11:08

The first version is not thread-safe for multiple threads may try to read and modify instance_ concurrently without any synchronization, which leads to a race condition.

The second version is thread-safe since C++11. Quoted from cppreference (the Static local variables section):

If multiple threads attempt to initialize the same static local variable concurrently, the initialization occurs exactly once (similar behavior can be obtained for arbitrary functions with std::call_once)

With this guarantee, modification to instance happens only once, and there is no problem with concurrent reads.

Still, the second version is not thread-safe until C++11.

score 1 · Answer 2 · edited May 23 '17 at 12:06

1

In former case, if two threads try to create the instance at the same time, 2 (or more) copies of singleton objects might be created. (if **instance_** is observed NULL by both and both create a new instance). (Even worse, thread creating first instance may get a different value of instance in subsequent calls)

While second one uses static initialization and object is constructed when the function is invoked for the first time. So it is guaranteed by the compiler that static FileSystem *instance = new FileSystem(); would be executed at most once during the lifetime of program single and thus atmist single copy of object would exist at any time.

This makes the later design thread safe for C++11 and onwards complian C++ compilers. Though the design may not be safe for in C++03 and C++98 implementation.

Another downside of former design is, the object can not be destructed while in later design it can be destructed by changing the typeof instance_ to static FileSystem. i.e.

static FileSystem& instance()
{
  static FileSystem instance;
  return instance;
}

Related: Is Meyers implementation of Singleton pattern thread safe?

edited May 23 '17 at 12:06

Community

1
1

answered Apr 19 '15 at 11:02

Mohit Jain

30,259
8
73
100

Thread-safe one-time initialization of local static variables is guaranteed only since C++11. And by defining a `FileSystem` instance, you defeat the goal of `lazy initialization`. `std::scoped_ptr` may be more appropriate here. – Lingxi Apr 19 '15 at 11:20
@Lingxi You are right section C++98 has no reference to multiple threads and referring to C++98 `3.6.3.1 [basic.start.term]` I would conclude the construct is unspecified. About lazy initialization, don't worry, compiler is already lazy in initializing static object. Try yourself. – Mohit Jain Apr 19 '15 at 11:25
Indeed. I did not though about this clearly. Even the pre-allocated storage for `FileSystem` is not a matter at all. – Lingxi Apr 19 '15 at 11:30
No @Lingxi, what I meant is little different. My point is, compiler would be lazy to defer the creation of instance as later as possible. (this has little overhead but yes compile does this way). Check [this example](http://ideone.com/BvTUov) for a better understanding. Static object is not created unless the flow of program encounters the required declaration. (I hope declaration is technically right word here) – Mohit Jain Apr 19 '15 at 11:31
I agree with you in that it does lazy-init the instance. However, it does not lazy-allocate the storage, which `instance_ = new FileSystem();` does. But again, as I have said, pre-allocate static storage does not matter much. – Lingxi Apr 19 '15 at 11:35
Sorry I missed the point before. Yes having static allocations are better than dynamic ones. They result in more rugged programs. – Mohit Jain Apr 19 '15 at 11:38

score 1 · Answer 3 · answered Apr 19 '15 at 11:05

In the first code snippet setting the instance_ pointer to a singleton is an assignment. It does not get any special treatment from the compiler. In particular, it could be done multiple times if instance() is invoked from concurrent threads.

This creates a problem when two concurrent threads try evaluating instance_ == NULL, and get a true. At this point both threads create a new instance, and assign it to the instance_ variable. The first pointer assigned to instance_ is leaked, because the second thread immediately overrides it, rendering the object inaccessible.

In the second code snippet setting the instance pointer is initialization. The compiler guarantees that initialization of a static variable will be done at most once, regardless of the number of threads that invoke instance() concurrently. Essentially, the guarantee that there is at most one singleton in the system is provided by the compiler, without any explicit code for handling concurrency.

This happens since C++11 only. – CreativeMind Apr 20 '15 at 13:03 — CreativeMind, Apr 20 '15 at 13:03

Differences between static declarations in singletons

3 Answers3