初学者 C++ 线程安全 singleton 设计

Question

I wish to create a static Class object which should stay in the memory while the program is running.The object needs to be initialized only once by the init function and the output function will be called in a static method always. Does my code make sense and is it thread-safe?

class Singleton
{
public: 
       static void init(const int value)
       {
              static Singleton inst;
              inst.Value = value;
       }
       static int prnValue()
       {
               return Value;
       }

private:
       Singleton() {};
       static int Value;
};

int main()
{
       int inputValue = 10;

       Singleton::init(inputValue);
       cout << Singleton::prnValue();

       return 0;
}

New Edit: Or can I try like this then?

class Singleton
{
public: 
       static Singleton& init(const int value)
       {
              static Singleton inst;
              inst.Value = value;

              return inst;
       }
       static int prnValue()
       {
               return Value;
       }

private:
       Singleton() {};
       static int Value;
};

Addition: Meyer's singleton example look like

class Singleton
{
public: 
       static Singleton& init()
       {
              static Singleton inst;

              return inst;
       }

private:
       Singleton() {};
};

So Isn't my code consistent with Meyer's example?

Try4: How about this?

class Singleton
{
public: 
       static Singleton& init(int value)
       {
              static Singleton inst(value);
              return inst;
       }
       static int prnValue()
       {
               return Value;
       }
private:
       Singleton(value) 
       {
              Value = value;
       }
       int Value;
};

Added comment: How to pass argument in a singleton seems to provide the same answer as Try4.

Answer 1

The first is just a very convoluted global variable. There is no need for the instance. inst.Value = value; is an obfuscated way to write Singleton.Value = value; . Really no offense, but I do not understand what should be the purpose of this code.

The second does return the instance, but that doesnt make the situation much better compared to the first. The instance has no non-static members and cannot be used for anything that you couldnt do without it. It basically is similar to the first.

As you are asking for thread-safety, there is none. Two threads may call init with differernt values and you will have two threads writing to the same memory resulting in a data race.

You should read about the Meyers singleton. It is based on the fact that function local static variables are guaranteed (not sure but I think since C++11, someone correct me in case I am wrong) to be initialized only once in a thread-safe way. To demonstrate only this aspect, consider:

struct Foo {
    static void bar(int x) {
        static int y = x; 
    }
};

This is thread-safe without any further measures to be taken, because y is guaranteed to be initialized only once.

In your code however, you have

static Singleton& init(const int value)
{
   static Singleton inst;
   inst.Value = value;     // <---
   return inst;
}

And in the line marked with the comment you do not get the nice feature of initialization of local static variables (initialized exactly once), hence you have a race condition.

My intention is to store the int value 10 throught the program

That is not a singleton but rather a

constexpr const int value = 10;

Globals should be avoided, but using a singleton is not avoiding a global. A singleton is a global. Rules have exceptions. Once you decided you really want to have a constant with value 10 that you can use throughout your program, you do have a global, so just use one.

Answer 2

Abandon Singleton and make Value a const global variable initialized with a helper function.

Example:

// anonymous namespace to bind the global to this file to prevent the static 
// initialization order fiasco
namespace 
{
    const int Value = ReadIniFile("section", "key", default_value);
}

But what if you need to use this variable in other files? The best advice I've got is don't. But if you must, the static initialization order fiasco needs to be overcome. Here's a quick way to do that that is similar to what you've seen so far:

// Lazy loader function similar to Meyers Singleton
int Value()
{
    static int value = ReadIniFile("section", "key", default_value);
    return value;
}

Usage:

me_function_need_Value(Value());

This ensures that Value is initialized before anyone can try to use it no matter which file in your project needs it. Unfortunately it's now hard to figure out when it goes out of scope, so the problem doesn't really go away. It's just moved from the start of the program to the end where it is a little more manageable. See Destruction order of static objects in C++ . Ensure no one uses Value after main exits and you'll be safe. Still, use with caution.