单例模式

单例模式介绍

单例模式有下面的特点：
1、单例类只能有一个实例。
2、提供一个访问它的全局访问点。

要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private。提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

单例模式的优点:

1. 在内存中只有一个对象,节省内存空间
2. 避免频繁的创建销毁对象,可以提高性能
3. 避免对共享资源的多重占用
4. 可以全局访问

单例模式的适用场景:

1. 需要频繁实例化然后销毁的对象
2. 创建对象耗时过多或者耗资源过多,但又经常用到的对象
3. 有状态的工具类对象
4. 频繁访问数据库或文件的对象
5. 以及其他要求只有一个对象的场景

单例模式实现

单例模式常见的写法有: 懒汉式，饿汉式。
懒汉式
懒汉式单例在第一次调用的时候初始化，有线程安全的问题。

#include <iostream>
using namespace std;

class singleton
{
private:
    static singleton *m_pInstance;
public:
    static singleton *getInstance();
    static void destoryInstance();
};

singleton* singleton::m_pInstance = NULL;

singleton* singleton::getInstance()
{
    std::cout << "getInstance enter" << std::endl;

    if (m_pInstance == NULL) {
        std::cout << "new singleton!" << std::endl;
        m_pInstance = new singleton();
    }

    return m_pInstance;
}

void singleton::destoryInstance()
{
    std::cout << "destoryInstance enter" << std::endl;

    if (m_pInstance != NULL) {
        std::cout << "delete m_pInstance!" << std::endl;
        delete m_pInstance;
        m_pInstance = NULL;
    }
}

int main(int argc, char const *argv[])
{
    singleton *siglt = singleton::getInstance();
    singleton *siglt2 = singleton::getInstance();

    singleton::destoryInstance();
    return 0;
}

饿汉式
饿汉是线程安全的，添加了一个互斥锁。

#include <iostream>
#include <pthread.h>
using namespace std;

class singleton
{
private:
    static singleton *m_pInstance;
public:
    static pthread_mutex_t singleton_mutex;
    static singleton *getInstance();
    static void destoryInstance();
};

singleton *singleton::m_pInstance = NULL;
pthread_mutex_t singleton::singleton_mutex = PTHREAD_MUTEX_INITIALIZER;

singleton *singleton::getInstance()
{
    std::cout << "getInstance enter" << std::endl;

    if (pthread_mutex_lock(&singleton_mutex) != 0) {
        return NULL;
    }

    if (m_pInstance == NULL) {
        std::cout << "new singleton!" << std::endl;
        m_pInstance = new singleton();
    }

    pthread_mutex_unlock(&singleton_mutex);

    return m_pInstance;
}

void singleton::destoryInstance()
{
    std::cout << "destoryInstance enter" << std::endl;

    if (m_pInstance != NULL) {
        std::cout << "delete m_pInstance!" << std::endl;
        delete m_pInstance;
        m_pInstance = NULL;
    }
}

int main(int argc, char const *argv[])
{
    singleton *siglt = singleton::getInstance();
    singleton *siglt2 = singleton::getInstance();

    singleton::destoryInstance();
    return 0;
}

PS：记录一下写法

#include <iostream>
using namespace std;

class singleton
{
private:
    static singleton *m_pInstance;

    singleton(void);

    class release
    {
    public:
        ~release() {
            std::cout << "~release" << std::endl;
        }
    };

    static release m_Release;

public:
    ~singleton();

    static singleton *getInstance();
};

singleton *singleton::m_pInstance = NULL;
singleton::release singleton::m_Release;

singleton::singleton(void)
{
}

singleton::~singleton()
{
}

singleton* singleton::getInstance(void)
{
    std::cout << "getInstance enter" << std::endl;

    if (m_pInstance == NULL) {
        std::cout << "new singleton!" << std::endl;
        m_pInstance = new singleton();
    }

    return m_pInstance;
}

int main(int argc, char const *argv[])
{
    singleton *siglt = singleton::getInstance();

    singleton *siglt2 = singleton::getInstance();

    return 0;
}