Can C 11\'s Initialization Guarantees Replace Mutexes for Thread-Safe Singleton Implementation?

Implementing Multithread-Safe Singleton in C 11 Without Mutexes

C 11 introduces multithreading features that enable efficient handling of concurrent execution. This article explores a lock-free approach to implementing a lazy initialization singleton in C 11, avoiding the use of heavy-weight mutexes for performance optimization.

Original Approach using Atomic Operations

The presented approach attempts to avoid mutexes by employing atomic operations. However, the proposed implementation relies on CAS (Compare-and-Swap) to prevent race conditions and may be susceptible to subtle concurrency issues.

C 11's Explicit Initialization Guarantees

C 11 introduces strong language guarantees regarding the initialization of static data members. According to §6.7 [stmt.dcl] p4 of the C 11 standard:

If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.

This means that under C 11, lazy initialization of static variables can be achieved without explicit locking, as the compiler will ensure proper initialization synchronization.

Implementing Singleton with Static Member Function

To utilize C 11's initialization guarantees, a simple static member function can be used to access the singleton instance:

<code class="cpp">static Singleton& get() {
  static Singleton instance;
  return instance;
}</code>

This implementation ensures thread-safe initialization of the singleton instance without the need for explicit locking, making it a viable option in C 11 environments.

Conclusion

While custom lock-free singleton implementations are possible, they can be complex and challenging to get right. In C 11, the built-in initialization guarantees provide a simple and more reliable solution for multithread-safe singleton implementation, obviating the need for complex low-level synchronization.

The above is the detailed content of Can C 11\'s Initialization Guarantees Replace Mutexes for Thread-Safe Singleton Implementation?. For more information, please follow other related articles on the PHP Chinese website!