connect to database only one time using singleton

Question

I'm trying to connect to the database only one time by using singleton pattern, below is my implementation.

Will it guarantee that the m_connector.connect(); is only called once?

Is using singleton the best solution?

class ConnectionManager
{
public:

  static ConnectionManager& getManager()
  {
    static ConnectionManager manager;
    return manager;
  }

  void reconnect();
  Connection getConnection();

private:
  ConnectionManager():m_connector("port")
  {
    m_connector.connect();
  };
  ConnectionManager(ConnectionManager const&);
  void operator=(ConnectionManager const&);

  Connector m_connector;
};

Did you write any unit tests to determine if `connect` is called more than once? Did you refer to the C++ Standard to see what the lifetime of objects with static [storage duration](http://en.cppreference.com/w/cpp/language/storage_duration)? — Captain Obvlious, May 11 '16 at 16:54
_"Will it guarantee that the m_connector.connect(); is only called once?"_ Hmm, `void reconnect();` somehow hints it might be called multiple times. — πάντα ῥεῖ, May 11 '16 at 17:29
@πάνταῥεῖ that's used when the connection is lost and retrying to connect. — user3828398, May 11 '16 at 17:43
@user3828398 Well, I can't know without seeing what the implementation does. It's under your control, but the singleton pattern alone cannot guarantee this function is called more than once. — πάντα ῥεῖ, May 11 '16 at 17:47
@WilliamKappler The constructor calls a member instances function, that's a big difference. — πάντα ῥεῖ, May 11 '16 at 18:55
@user3828398 Are you actually worrying about thread safety? The pattern you use is guaranteed to be thread safe with the current standard. — πάντα ῥεῖ, May 11 '16 at 18:56
@πάνταῥεῖ You are correct, I seem to have missed that. — , May 11 '16 at 18:59
@πάνταῥεῖ so all threads share the same connectionmanager? — user3828398, May 12 '16 at 07:28
@πάνταῥεῖ and if I want each thread to have a separate connectionmanager, I need to use `thread_local` instead of `static`, right? — user3828398, May 12 '16 at 07:32
@user3828398 _"so all threads share the same connectionmanager? "_ Well, I don't know? That depends on your implementation. Currently it would be like that, yes. — πάντα ῥεῖ, May 12 '16 at 07:33
@user3828398 _"I need to use thread_local instead of static, right?"_, well don't use a singleton then. — πάντα ῥεῖ, May 12 '16 at 07:34

score 0 · Answer 1 · edited May 23 '17 at 12:31

Will it guarantee that the m_connector.connect(); only run once?

No.

The only fact that's guaranteed in that case of implementation (aka as Scott Meyer's Singleton) is that the constructor of ConnectionManager is called once and only once.

  static ConnectionManager& getManager()
  {
    static ConnectionManager manager;
    return manager;
  }

It will be called as soon ConnectionManager::getManager(); is called the first time.

The constructor in turn calls m_connector.connect()

  ConnectionManager():m_connector("port")
  {
    m_connector.connect();
  };

There's no guarantee that

    m_connector.connect();

won't be called from any other parts of your code. The declaration of

  void reconnect();

even implies that somehow.

But well, it's all under your control.

If the constructor is the only function that calls m_connector.connect();, and you are worrying about thread safety, you shouldn't need to. It's guaranteed to be thread safe with the current standard.

Is using singleton the best solution?

Probably not. Nothing should hinder you to revise your decisions later, and to decide you actually need to have more ConnectionManager instances.

Any other part of your code that will use ConnectionManager::getManager(); is tightly coupled to that singleton class, and it will become hard to refactor your code if it should be made more generic.

This kind of hardcoding a DB connection

  ConnectionManager():m_connector("port")
                               // ^^^^^^

extremely narrows the scalability of your application.

I personally would make it a class, with the appropriate constructor parameters to create a connection, and having a public (abstract) interface implemented, that can be accessed via a factory function, or some of the other Creational Design Patterns dedicated to instance creation, and nothing else.

connect to database only one time using singleton

1 Answers1