Is Meyers' Singleton Thread-Safe?

Meyers' Singleton: Thread Safety Evaluation and Enhancement

The Meyers' implementation of the Singleton pattern utilizes lazy initialization, but its thread safety remains a concern. This article delves into the intricacies of thread safety in the given code:

static Singleton& instance()
{
     static Singleton s;
     return s;
}

In C 11 and Beyond

In C 11, lazy initialization of global objects is thread safe by virtue of the standard's guarantee: concurrent initialization will cause waiting until its completion. Both GCC and Visual Studio support this feature.

Therefore, in a C 11 or later environment, Meyers' Singleton implementation is thread safe.

In C 03 and Prior

In C 03 and earlier, the provided code is not thread safe. As described by Meyers in his article, double-checked locking patterns can be susceptible to race conditions on certain architectures. To achieve thread safety in this context, a full lock around the instantiation method is recommended.

Code for C 03 Thread Safety

Here is a modification of the code for C 03 thread safety:

static Singleton*& instance()
{
    static Singleton* s = nullptr;
    static std::mutex s_mutex;

    std::lock_guard<std::mutex> guard(s_mutex);
    if (!s)
        s = new Singleton;

    return s;
}

This implementation employs a mutex to synchronize access during initialization, ensuring thread safety.

The above is the detailed content of Is Meyers' Singleton Thread-Safe?. For more information, please follow other related articles on the PHP Chinese website!