设计模式学习--单例模式

在设计模式中，单例模式是最常见的一种模式。下面是本人学习单例模式的一些总结。用java和C++两种语言实现单例模式

定义

确保一个类只有一个实例，并提供一个全局访问点。

实现方法

如何在实际软件中，做到类只有一个实例呢。最简单的方法，就是使类的构造函数私有，这样类的使用者，就不能创建类的实例，然后，再提供统一的获取类实例的方法。

下面就给出Java和C++两种具体语言的实现。

JAVA实现方法

静态变量

Singleton最简单的方法，就是直接声明一个static变量，并且进行初始化，这样类在加载的时候，就会初始化实例。

public class Singleton
{
    private volatile static Singleton singleton = new Singleton();
    private Singleton()  {    }
    public static Singleton getInstance()   {
        return singleton;
    }
}

双检锁

使用双检索的方式，必须添加volatile关键字，
因为JVM的重排序，会导致未被初始化的实例.

public class Singleton
{
    private volatile static Singleton singleton = null;
    private Singleton(){}

    public static Singleton getInstance(){
        if (singleton== null)  {
            synchronized (Singleton.class) {
                if (singleton== null)  {
                    //没有volatile关键字会因为重排序，导致singleton!=null，而实例未被成功初始化
                    singleton= new Singleton();
                }
            }
        }
        return singleton;
    }
}

enum实现

使用jdk1.5之后的enum可以很方便实现单例。

public enum Singleton {
    INSTANCE;
}

C++实现方法

C++和java差不多，但C++中的构造函数种类比较多，有普通构造函数，有拷贝构造函数。为了避免实例被外部delete，可以将类的析构函数也私有，这样在外部调用delete的时候，也会有编译错误。

静态局部变量

C++最简单的方式，就是使用静态局部变量。在第一次获取instance的时候，会进行初始化。

#include <iostream>
using namespace std;

class Singleton{
public:
    static Singleton& getInstance(){
        static Singleton instance;
        return instance;
    }

    void print(){
        cout << "Hello, my data:" << data << endl;
    }
    void add(int i){
        data += i;
    }

private:
    Singleton(){
        data = 0;
    };

    Singleton(Singleton &){}
    ~Singleton(){}

    int data;
};

int main(int argc, const char* argv[]) {
    Singleton & s1 = Singleton::getInstance();
    Singleton & s2 = Singleton::getInstance();
    s1.print();
    s2.add(2);
    s1.print();
}

但这种方式，在C++0x之前，是线程不安全的，C++0x之后，局部静态变量是线程安全的。

静态变量

C++中，为了避免C++中局部变量的线程安全问题，可以将局部静态变量放到类的静态变量中。

#include <iostream>
using namespace std;

class Singleton{
public:
    static Singleton& getInstance(){
        return instance;
    }

    void print(){
        cout << "Hello, my data:" << data << endl;
    }
    void add(int i){
        data += i;
    }
private:
    static Singleton instance;

private:
    Singleton(){
        data = 0;
    };
    Singleton(Singleton &){}
    ~Singleton(){}

    int data;
};

Singleton Singleton::instance ;

int main() {
    Singleton & s1 = Singleton::getInstance();
    Singleton & s2 = Singleton::getInstance();
    s1.print();
    s2.add(2);
    s1.print();

    return 0;
}

这种实现，有个问题，单例的初始化，是类的静态初始化时完成的，无法控制两个类的初始化顺序。如果有两个单例相互依赖，则会有问题。

双检锁

为了使用延迟初始化，同时解决线程安全问题，可以使用双检锁的方式，先判断实例是否为空，如果为空，则加锁，加锁后，再进行一次为空判断。这样，只有在单例被初始化的时候，才会有加锁的性能问题。

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

class Singleton{
public:
    static Singleton& getInstance(){
        if (instance == NULL){
            m.lock();
            if (instance == NULL){
                instance = new Singleton();
            }
            m.unlock();
        }
        return *instance;
    }

    void print(){
        cout << "Hello, my data:" << data << endl;
    }
    void add(int i){
        data += i;
    }

private:
    static Singleton* instance;// = new Singleton();
    static mutex m;
private:
    Singleton(){
        data = 0;
    };
    Singleton(Singleton &){}
    ~Singleton(){}

    int data;
};

Singleton* Singleton::instance = NULL;
mutex Singleton::m;

int main(int argc, const char* argv[]) {
    Singleton & s1 = Singleton::getInstance();
    Singleton & s2 = Singleton::getInstance();
    s1.print();
    s2.add(2);
    s1.print();

    return 0;
}

单例角

如果有多个单例，都想使用双检锁的方法，
利用C++的模板和friend友元功能，可以快速产生单例类

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

template<class T>
class Singleton{
public:
    static T& getInstance(){
        if (nullptr == instance){
            m.lock();
            if (nullptr == instance){
                instance = new T();
            }
            m.unlock();
        }
        return *instance;
    }

private:
    static T* instance;
    static mutex m;

protected:
    Singleton(){};
    Singleton(Singleton &){}
    ~Singleton(){}
};

template<class T>
T* Singleton<T>::instance = nullptr;

template<class T>
mutex Singleton<T>::m;

class MyClass : public Singleton<MyClass>{
    friend class Singleton<MyClass>;

public:
    void print(){
        cout << "Hello, my data:" << data << endl;
    }
    void add(int i){
        data += i;
    }

private:
    MyClass():data(0){}
    MyClass(MyClass &){}
    ~MyClass(){}

    int data;
};

int main(int argc, const char* argv[]) {
    MyClass & s1 = MyClass::getInstance();
    MyClass & s2 = MyClass::getInstance();
    s1.print();
    s2.add(2);
    s1.print();

    return 0;
}

应用场景

在现实中，有很多地方都是需要用到单例模式的，比如全局配置信息，数据库连接池