Lets learn "Singleton design pattern"

-

 In this tutorial, we'll learn about the singleton design patterns as in what it is, in which use-cases it is being used and how it works. If you've are not familiar with what are software design patterns and what are its different types check out this tutorial.

Introduction

A factory design pattern is a creational design pattern that is related to object creation. This design pattern restricts to create only one object of the class. Whenever the client tries to instantiate a class, if this is the first time we are instantiating it will create an actual object, from next time onwards it will return the same object instead of creating a new one.

Usecases 

There are a lot of use-cases where this pattern is useful. One of the common use cases is creating a DB connection. If you have a monolithic application and you wanna perform DB operation from multiple places in the app. To do any DB operation you need to connect to the DB first. And we should not be creating a new connection every time. Instead, we can create one and use that connection every time. To achieve that we can use the singleton pattern and have a method NewDBConnection() which will always return the same connection object it exists, otherwise, create one.

Examples

#include<iostream>
#include<map>
#include<string>
#include <mutex>
using namespace std;

class DB {
    private:
    static DB* connection;
    map<string, string> dataStore;

    // private constructor it cannot be called outside the class
    DB() {}

    public:
    static DB* newDBConnection() {
        if(connection == NULL){
            connection = new DB;
        }
        return connection;
    }

    void put(string key, string value) {
        dataStore.insert(make_pair(key, value));
    }

    string get(string key) {
        return dataStore[key];
    }
};

//Initialize pointer to zero so that it can be initialized in first call to getDBConnection
DB *DB::connection = 0;

int main(){
    DB* conn1 = conn1->newDBConnection();
    conn1->put("lets", "learn");

    // re-instantiation should not create new instance
    DB* conn2 = conn2->newDBConnection();
    
    // hence should use the same datastore and return "learn"
    cout<<conn2->get("lets")<<endl;
    return 0;
}

The issue with the above example is that the getDBConnection is not thread-safe which means if multiple threads try to instantiate the DB class at the same time we might end up having multiple of instances of DB class created. Now let's see how we can avoid that.

#include<iostream>
#include<map>
#include<string>
#include <mutex>
using namespace std;

mutex mtx;
class DB {
    private:
    static DB* connection;
    map<string, string> dataStore;

    // private constructor it cannot be called outside the class
    DB() {}

    public:
    static DB* newDBConnection() {
        mtx.lock();
        if(connection == NULL){
            connection = new DB;
        }
        mtx.unlock();
        return connection;
    }

    void put(string key, string value) {
        dataStore.insert(make_pair(key, value));
    }

    string get(string key) {
        return dataStore[key];
    }
};

//Initialize pointer to zero so that it can be initialized in first call to getDBConnection
DB *DB::connection = 0;

int main(){
    DB* conn1 = conn1->newDBConnection();
    conn1->put("lets", "learn");

    // re-instantiation should not create new instance
    DB* conn2 = conn2->newDBConnection();
    
    // hence should use the same datastore and return "learn"
    cout<<conn2->get("lets")<<endl;
    return 0;
}

But having mutex lock while object creation will affect the performance. Because as you can see in the above program every time we call NewDBConnection we need to lock and unlock mutex irrespective of an object is created before or not. Let's see how we can improve it further.

#include<iostream>
#include<map>
#include<string>
#include <mutex>
using namespace std;

mutex mtx;
class DB {
    private:
    static DB* connection;
    map<string, string> dataStore;

    // private constructor it cannot be called outside the class
    DB() {}

    public:
    static DB* newDBConnection() {
        if(connection == NULL){
            mtx.lock();
            if(connection == NULL) {
                connection = new DB;
            }
            mtx.unlock();
        }
        return connection;
    }

    void put(string key, string value) {
        dataStore.insert(make_pair(key, value));
    }

    string get(string key) {
        return dataStore[key];
    }
};

//Initialize pointer to zero so that it can be initialized in first call to getDBConnection
DB *DB::connection = 0;

int main(){
    DB* conn1 = conn1->newDBConnection();
    conn1->put("lets", "learn");

    // re-instantiation should not create new instance
    DB* conn2 = conn2->newDBConnection();
    
    // hence should use the same datastore and return "learn"
    cout<<conn2->get("lets")<<endl;
    return 0;
}

Now with above program, we'll be locking/unlocking if the object is not created before for which no. of hits will be less. So this won't affect performance much and that's the best way to use a singleton pattern.

HOPE YOU LIKE THIS TUTORIAL. FEEL FREE TO COMMENT BELOW IF YOU HAVE ANY DOUBTS. AND STAY TUNED FOR MORE TUTORIALS :)
Happy Learning!

Comments

Post a Comment

Popular posts from this blog

Lets learn "About kube proxy in iptables mode"

-
Image
In this tutorial, we'll learn about the Kube-proxy in iptables mode. Basically, we'll see how Kube-proxy create iptables that help in load balancing and service discovery. If you are not familiar with Linux IPTables I would recommend to check out my tutorial on IPTables here  first and then come back to read this tutorial. Kube-proxy Kube-proxy when running in iptables mode basically watch kube-apiserver for new endpoints and create corresponding iptables rules and iptables are fully responsible for service discover and proper routing of traffic to corresponding pods. Kube-proxy needs to run on all k8s worker nodes. Below is a small video describing the working of kube-proxy in iptables mode.  src:  https://www.slideshare.net/CJCullen/kubernetes-networking-55835829 Now that we know what Kube-proxy is and how it Kube-proxy works, let deep dive into the types of iptables Kube-proxy adds to the firewall. Kube-proxy added IPTables To learn this let's consider an example. Consid
Read more

Lets learn "System design for paste bin (or any text sharing website)"

-
Image
  In this tutorial, we'll learn about the system design for PasteBin. If you don't know what Pastebin is here goes its definition. Pastebin is a type of online content hosting service where users can store texts to share with others over the internet.  Pastebin system design requirements  Functional Basic - User should be able to paste the text, generate the link and share the link with other users. There should be the max size of the text that our system will support (say 10Mb) Users should be able to provide the custom URL path for the link created. Like if a user wants to create the links  www.pb.com/letlearn, he can give this URL and pastebin should create a link using this URL to share with others. The link or paste expiry feature should be there for each stored text. There can be default expiry time say 1 year but this should be configurable. Personalization means the user should be able to login to track all the pastes created by him and manage them. Non-Functional Durab
Read more

Lets learn "Factory design pattern"

-
 In this tutorial, we'll learn about the factory design pattern as in what it is, in which use cases this is being used and how it works. If you've are not familiar with what are software design patterns and what are its different types check out this tutorial. Introduction A factory design pattern is a creational design pattern that is related to object creation. In this pattern, we'll have a method to create an object without exposing its creation logic to the client. If a class method is creating an object it has to be static.  The idea is to create a static method ( factory method ) which instantiates a class without exposing its logic to the client and the client can use that method every time it needs to create an object of the class. The reason why the factory pattern is useful is that as it does not expose the logic of object creation, so if logic is changed, the client code need not to be changed. Usecases The place where this pattern is mostly used is library cod
Read more