【C/C++】探索单例模式：线程安全与性能优化

Singleton

1 指针版本

Version 1 非线程安全版本

class Logger {
public:
    static Logger *GetInstance() {
        if (instance == nullptr) {
            instance = new Logger();
        }

        return instance;
    }

    void Log(const std::string &message) {
        std::cout << message << std::endl;
    }

private:
    static Logger *instance;

    Logger() {}
};

Logger *Logger::instance = nullptr;

Version 2 加锁版本

增加锁，用于保证线程安全，但是锁开销会影响性能。

class Logger {
public:
    static Logger *GetInstance() {
        std::lock_guard<std::mutex> lk(mutex_);

        if (instance == nullptr) {
            instance = new Logger();
        }

        return instance;
    }

    void Log(const std::string &message) {
        std::cout << message << std::endl;
    }

private:
    Logger() {}

    static Logger *instance;
    static std::mutex mutex_;
};

Logger *Logger::instance = nullptr;
std::mutex Logger::mutex_;

Version 3.1 双重检查锁版本 Atomic+Mutex

class Logger {
public:
    static Logger* GetInstance() {
        // First, attempt to load the current instance atomically
        Logger* tmp = instance.load(std::memory_order_acquire);
        
        // If the instance is nullptr, create it
        if (tmp == nullptr) {
            std::lock_guard<std::mutex> lock(mtx);  // Lock only during initialization
            
            tmp = instance.load(std::memory_order_relaxed);  // Check again inside the lock
            
            if (tmp == nullptr) {
                tmp = new Logger();  // Create a new instance
                instance.store(tmp, std::memory_order_release);  // Atomically set the instance
            }
        }

        return tmp;
    }

    void Log(const std::string& message) {
        std::cout << message << std::endl;
    }

    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger() {}  // Private constructor to prevent direct instantiation

    static std::atomic<Logger*> instance;  // Atomic pointer to the Singleton instance
    static std::mutex mtx;  // Mutex to protect initialization
};

// Initialize the atomic pointer and mutex
std::atomic<Logger*> Logger::instance(nullptr);
std::mutex Logger::mtx;

Version 3.2 双重检查锁版本 Atomic-only

class Logger {
public:
    static Logger* GetInstance() {
        // First, attempt to load the current instance atomically
        Logger* tmp = instance.load(std::memory_order_acquire);
        
        // If the instance is nullptr, create it
        if (tmp == nullptr) {
            tmp = new Logger();  // Create a new instance
            
            // Atomically set the instance if no other thread has done so
            if (!instance.compare_exchange_strong(tmp, tmp)) {
                delete tmp; // Another thread won the race, delete the temporary instance
                tmp = instance.load(std::memory_order_acquire); // Reload the instance
            }
        }

        return tmp;
    }

    void Log(const std::string& message) {
        std::cout << message << std::endl;
    }

    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger() {}  // Private constructor to prevent direct instantiation

    static std::atomic<Logger*> instance;  // Atomic pointer to the Singleton instance
};

// Initialize the atomic pointer to nullptr
std::atomic<Logger*> Logger::instance(nullptr);

Version 3 两种方式对比

• Only Atomic:

  • Atomic Check: We first check the instance atomically with instance.load. If it’s nullptr, we attempt to create the instance using new.
  • Atomic Set: We use compare_exchange_strong to ensure that only one thread creates the instance. If another thread has already created the instance, it returns the existing one.
  • No Mutex: There is no mutex involved here. The atomic operations ensure thread safety during the initialization phase.

• Atomic + Mutex:

  • Atomic First Check: The first check of the instance pointer is atomic using instance.load.
  • Mutex Locking: If the instance is nullptr, we lock a mutex (std::mutex mtx) to synchronize access during the actual creation of the instance.
  • Double Check Inside Lock: After acquiring the mutex, we perform another check of the instance. This prevents other threads from creating multiple instances if they were waiting on the mutex.
  • Atomic Set: We use instance.store to atomically set the instance pointer once it’s initialized.

• Comparison of Effectiveness:

• Atomic-only approach is more effective in high-concurrency environments, especially when you expect many threads accessing the Singleton. Since the initialization is thread-safe and lock-free after the instance is created, it scales much better than the mutex-based approach.

• Atomic + Mutex approach might be easier to understand for developers familiar with mutexes and might work well in lower-concurrency environments. However, the mutex adds overhead for each access, and if the program has many threads, it will result in contention and slower performance.

• If you are building a highly concurrent system, prefer the atomic-only approach, as it will perform better with minimal locking overhead.

• If you have a simpler, lower-concurrency application, using atomic + mutex might be a good trade-off because it provides simplicity and guarantees correct initialization with easy-to-understand synchronization.

2 引用版本

Version 1 简单版本 不推荐

class Logger {
public:
    static Logger &GetInstance() {
        return instance;
    }

    void Log(const std::string &message) {
        std::cout << message << std::endl;
    }
    
private:
    static Logger instance;
    Logger() {
    }
};

Logger Logger::instance;

Version 2 初始化安全版本

c++机制保证初始化安全

class Logger {
public:
    static Logger& GetInstance() {
        static Logger instance;

        return instance;
    }

    void Log(const std::string &message) {
        std::cout << message << std::endl;
    }

    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger() {}
};

Version 3 初始化+操作安全版本

增加操作安全

class Logger {
public:
    static Logger &GetInstance() {
        static Logger instance;

        return instance;
    }

    void Log(const std::string &message) {
        std::lock_guard<std::mutex> lk(mtx);

        std::cout << message << std::endl;
    }


    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

private:
    Logger() {}
    std::mutex mtx;
};

Explanation

初始化过程线程安全原因：

1. Static Local Variable:

   • In the GetInstance() method, we declare a static local variable instance.

     • static Logger instance; ensures that instance is only created once and persists for the entire lifetime of the program.

2. First-Time Initialization:

   • The first time GetInstance() is called, the static variable instance is initialized. This is where the thread-safety comes into play. The C++11 standard guarantees that the initialization of a static local variable will be thread-safe.
   • If multiple threads try to call GetInstance() simultaneously, only one thread will initialize the instance. The other threads will wait until the initialization is complete, and then they will all see the same instance when they call GetInstance() again.

3. Thread-Safe Static Initialization:

   • The C++11 guarantee ensures that even if multiple threads try to initialize the instance simultaneously, the static variable will only be initialized once. The other threads will see the already initialized object, which eliminates any race condition.

4. Post-Initialization Access:

   • After initialization, the reference instance is ready for access, and since it is a static variable, it is always available. There is no locking required for accessing instance after it is initialized, making access very efficient.

5. No Mutex or Atomic Operations:

   • Since the C++ standard guarantees thread-safe initialization of static local variables, there is no need for additional synchronization mechanisms such as mutexes or atomic operations. The instance is initialized only once, and once it is initialized, it is ready for fast, lock-free access.

Comparison