C++ lazy singleton hangs on loading - c++

Question

I have lazy singleton class, that needs to be serialized using boost on the first call.
Header file:
class Singleton
{
public:
static Singleton& Instance()
{
static Singleton theSingleInstance;
return theSingleInstance;
}
void load();
private:
Singleton();
Singleton(const Singleton& root);
Singleton& operator=(const Singleton&);
std::map<std::string,std::string > m_desc;
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive& arc, const unsigned int version)
{
arc & BOOST_SERIALIZATION_NVP(m_desc);
}
const char* FILENAME = "./config.xml";
};
Source file
#include "singleton.h"
Singleton::Singleton()
{
load();
}
void Singleton::load()
{
try
{
std::ifstream f(FILENAME);
boost::archive::xml_iarchive arc(f);
arc & boost::serialization::make_nvp("Config",Instance());
}
catch(...)
{
std::cout << "Exception" << std::endl;
}
}
So when I try to start my code using this singleton, it hangs. With the debugger I can see that it does not go to load() method many times (and it's ok). When I pause the debugger, it stops on the line return theSingleInstance;, but it does not go through the breakpoint on this line many times also. What am I doing wrong?

Answer 1

You call load from inside the constructor. Which means that you're in the constructor of your static theSingleInstance when you... call Instance
:
#0 in Singleton::load at test.cpp <test.cpp>
#1 in Singleton::Singleton at test.cpp <test.cpp>
#2 in Singleton::Instance at test.cpp <test.cpp>
#3 in main at test.cpp <test.cpp>
Since construction c++11 function-local statics is guaranteed to be thread safe, which means - in your implementation - that execution will block until the instance is fully constructed (or construction failed, so it can be retried).
Of course, that will never happen because construction is waiting for itself.
0x00000000004030f5 <+629>: callq 0x402be0 <__cxa_guard_acquire#plt>
=> 0x00000000004030fa <+634>: test %eax,%eax
0x00000000004030fc <+636>: je 0x402ff1 <Singleton::load()+369>
Of course this is fixed by not using the external accessor while still constructing the instance, as you already found out.

Answer 2

You might want to consider the practice of giving singletons value-semantics - in case one day you don't want it to be a singleton any more and you want to avoid refactoring.
The other advantage is that it provides full encapsulation:
for example:
// config.h - extremely sparse interface
#include <string>
struct config
{
/// Return a named value from the program's configuration
/// #param name is the name of the required parameter
/// #post the config file shall be cached
/// #return the value if it exists
/// #except std::invalid_argument if the value does not exist
/// #except other exceptions if the config file does not load
///
const std::string& value(const std::string& name) const;
private:
struct impl;
static impl& get();
};
// config.cpp - the implementation
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/map.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <fstream>
#include <map>
struct config::impl
{
impl()
{
std::ifstream f(FILENAME);
boost::archive::xml_iarchive arc(f);
arc & boost::serialization::make_nvp("Config", *this);
}
std::map<std::string,std::string > m_desc;
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive& arc, const unsigned int version)
{
arc & BOOST_SERIALIZATION_NVP(m_desc);
}
static constexpr const char* FILENAME = "./config.xml";
};
config::impl& config::get() {
static impl _;
return _;
}
const std::string& config::value(const std::string& name) const
{
return get().m_desc.at(name);
}
// demo.cpp
// note - config is copyable, and this has almost no cost
void do_something_with(config cfg)
{
}
struct no_config {}; // some other config source?
// now I can switch on config type at compile time - code can be
// more generic
void do_something_with(no_config)
{
}
int main()
{
// single-use
std::string my_value = config().value("foo");
// pass my config source to a function
do_something_with(config());
// a similar function that uses a different config source
do_something_with(no_config());
return 0;
}

Answer 3

The answer was simple: to replace this line
arc & boost::serialization::make_nvp("Config",Instance());
with
arc & boost::serialization::make_nvp("Config",*this);