单例模式

张威大约 7 分钟

单例模式

什么是单例模式

单例模式是指在整个系统生命周期内，保证一个类只能产生一个实例，确保该类的唯一性。

为什么需要单例模式

节省资源。一个类只有一个实例，不存在多份实例，节省资源。
方便控制。在一些操作公共资源的场景时，避免了多个对象引起的复杂操作。

线程安全

什么是线程安全？

在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

如何保证线程安全？

给共享的资源，保证每个资源变量每时每刻至多被一个线程占用。
让线程也拥有资源，不用去共享进程中的资源。如：使用threadlocal可以为每个线程维护一个私有的本地变量。

单例类的特点

构造函数和析构函数为私有类型，目的是禁止外部构造和析构。
拷贝构造函数和赋值构造函数是私有类型，目的是禁止外部拷贝和赋值，确保实例的唯一性。
类中有一个获取实例的静态方法，可以全局访问。

单例模式分类

单例模式可以分为 懒汉式 和 饿汉式 ，两者之间的区别在于创建实例的时间不同。

懒汉式

系统运行中，实例并不存在，只有当需要使用该实例时，才会去创建并使用实例。这种方式

饿汉式

在编译期就初始化创建实例，当需要时，直接调用即可。这种方式本身就线程安全，没有多线程的问题。

优点：线程安全
缺点：
1. 浪费内存，即使对象没有使用也会被创建
2. 不能加载一些运行时的资源

单例模式实现

单例的经典实现方式是「」，推荐使用这种方式。

普通懒汉式单例（线程不安全）

这种情况是线程不安全的，不作详细介绍。

加锁的懒汉式单例（线程安全）

使用互斥锁保证线程安全。

方法1：返回普通指针

///  加锁的懒汉式实现  //

class SingleInstance
{

public:
    // 获取单实例对象
    static SingleInstance *GetInstance();

    //释放单实例，进程退出时调用
    static void deleteInstance();
	
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    SingleInstance();
    ~SingleInstance();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    SingleInstance(const SingleInstance &signal);
    const SingleInstance &operator=(const SingleInstance &signal);

private:
    // 唯一单实例对象指针
    static SingleInstance *m_SingleInstance;
    static std::mutex m_Mutex;
};

源文件：

//初始化静态成员变量
SingleInstance *SingleInstance::m_SingleInstance = nullptr;
std::mutex SingleInstance::m_Mutex;

// 注意：不能返回指针的引用，否则存在外部被修改的风险！
SingleInstance * SingleInstance::GetInstance()
{

    //  这里使用了两个 if 判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
    //  避免每次调用 GetInstance的方法都加锁，锁的开销毕竟还是有点大的。
    if (m_SingleInstance == nullptr) 
    {
        std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
        if (m_SingleInstance == nullptr)
        {
            volatile auto temp = new (std::nothrow) SingleInstance();
            m_SingleInstance = temp;
        }
    }

    return m_SingleInstance;
}

void SingleInstance::deleteInstance()
{
    std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
    if (m_SingleInstance)
    {
        delete m_SingleInstance;
        m_SingleInstance = nullptr;
    }
}

void SingleInstance::Print()
{
	std::cout << "我的实例内存地址是:" << this << std::endl;
}

SingleInstance::SingleInstance()
{
    std::cout << "构造函数" << std::endl;
}

SingleInstance::~SingleInstance()
{
    std::cout << "析构函数" << std::endl;
}

方法2：返回智能指针

#include <iostream>
#include <memory>
#include <mutex>


class Singleton {

public:

    static std::shared_ptr<Singleton> getSingleton();

    void print() {
        std::cout << "Hello World." << std::endl;
    }

    ~Singleton() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

private:

    Singleton() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

static std::shared_ptr<Singleton> singleton = nullptr;
static std::mutex singletonMutex;

std::shared_ptr<Singleton> Singleton::getSingleton() {
    if (singleton == nullptr) {
        std::unique_lock<std::mutex> lock(singletonMutex);
        if (singleton == nullptr) {
            volatile auto temp = std::shared_ptr<Singleton>(new Singleton());
            singleton = temp;
        }
    }
    return singleton;
}

静态局部变量的懒汉单例（C++11线程安全）

头文件：

///  内部静态变量的懒汉实现  //

class Single
{

public:
    // 获取单实例对象
    static Single& GetInstance();
	
	// 打印实例地址
    void Print();

private:
    // 禁止外部构造
    Single();

    // 禁止外部析构
    ~Single()

    // 禁止外部拷贝构造
    Single(const Single &single) = delete;

    // 禁止外部赋值操作
    const Single &operator=(const Single &single) = delete;
};

源文件：

Single& Single::GetInstance()
{
    /**
     * 局部静态特性的方式实现单实例。
     * 静态局部变量只在当前函数内有效，其他函数无法访问。
     * 静态局部变量只在第一次被调用的时候初始化，也存储在静态存储区，生命周期从第一次被初始化起至程序结束止。
     */
    static Single single;
    return single;
}

void Single::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

Single::Single()
{
    std::cout << "构造函数" << std::endl;
}

Single::~Single()
{
    std::cout << "析构函数" << std::endl;
}

饿汉式单例（线程安全）

头文件：

// 饿汉实现 /

class Singleton
{
public:
    // 获取单实例
    static Singleton* GetInstance();

    // 释放单实例，进程退出时调用
    static void deleteInstance();
    
    // 打印实例地址
    void Print();

private:
    // 将其构造和析构成为私有的, 禁止外部构造和析构
    Singleton();
    ~Singleton();

    // 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
    Singleton(const Singleton &signal);
    const Singleton &operator=(const Singleton &signal);

private:
    // 唯一单实例对象指针
    static Singleton *g_pSingleton;
};

源文件：

// 代码一运行就初始化创建实例 ，本身就线程安全
Singleton* Singleton::g_pSingleton = new (std::nothrow) Singleton();

Singleton* Singleton::GetInstance()
{
    return g_pSingleton;
}

void Singleton::deleteInstance()
{
    if (g_pSingleton)
    {
        delete g_pSingleton;
        g_pSingleton = nullptr;
    }
}

void Singleton::Print()
{
    std::cout << "我的实例内存地址是:" << this << std::endl;
}

Singleton::Singleton()
{
    std::cout << "构造函数" << std::endl;
}

Singleton::~Singleton()
{
    std::cout << "析构函数" << std::endl;
}

使用 C++11 std::call_once 实现单例（C++11线程安全）

#include <iostream>
#include <memory>
#include <mutex>

class Singleton {
public:
    static std::shared_ptr<Singleton> getSingleton();

    void print() {
        std::cout << "Hello World." << std::endl;
    }

    ~Singleton() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

private:
    Singleton() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

static std::shared_ptr<Singleton> singleton = nullptr;
static std::once_flag singletonFlag;

std::shared_ptr<Singleton> Singleton::getSingleton() {
    std::call_once(singletonFlag, [&] {
        singleton = std::shared_ptr<Singleton>(new Singleton());
    });
    return singleton;
}

单例模式的自动释放

使用单例设计模式的过程中，也难免会遇到内存泄漏的问题。那么是否有一个方法，可以让对象自动释放，而不需要程序员自己手动去释放呢？在学习了嵌套类之后，我们就可以完美的解决这一问题。在涉及到自动的问题时，我们很自然的可以想到：当对象被销毁时，会自动调用其析构函数。利用这一特性，我们可以解决这一问题。

可以使用友元形式进行设计

//1、友元实现单例对象的自动释放
class AutoRelease;
class Singleton
{
    friend AutoRelease;
public:
    static Singleton *getInstance()
     {
        if(nullptr == _pInstance)
        {
            _pInstance = new Singleton();
        }
        return _pInstance;
    }
    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance; //1、调用析构函数 2、operator delete
            _pInstance = nullptr;
        }
    }
private:
    Singleton() 
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton() 
    {
        cout << "~Singleton()" << endl;
    }
private:
    static Singleton *_pInstance;
};

Singleton *Singleton::_pInstance = nullptr;
class AutoRelease
{
public:
    AutoRelease()
    {
        cout << "AutoRelease()" << endl;
    }
    ~AutoRelease()
    {
        cout << "~AutoRelease()" << endl;
        if(Singleton::_pInstance)
        {
            delete Singleton::_pInstance;//1、调用析构函数 2、operator delete
            Singleton::_pInstance = nullptr;
        }
    }
};

内部类加静态数据成员形式

class Singleton 
{
public:
    static Singleton * getInstance()
    {
        if(_pInstance == nullptr)
        {
            _pInstance = new Singleton();
        }
        return _pInstance;
    }
    
private:
    class AutoRelease 
    {
    public:
        AutoRelease() 
        {
            cout << "AutoRelease()" << endl;
        }
        
        ~AutoReleas() 
        {
            cout << "~AutoRelease()" << endl;
            
            if(_pInstance) 
            {
                delete _pInstance;
                _pInstance = nullptr;
            }
        }
    };
private:
    Singleton() 
    {
         cout << "Singleton()" << endl;
    }
    
    ~Singleton() 
    {
         cout << "~Singleton()" << endl;
    }
    
private:
    static Singleton *_pInstance;
    static AutoRelease  _auto;
};

atexit方式进行

class Singleton
{
public:
    static Singleton *getInstance()
    {
        //对于多线程环境，不安全
        if(nullptr == _pInstance)
        {
            _pInstance = new Singleton();
            atexit(destroy);
        }
        return _pInstance;
    }
    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance;//1、调用析构函数 2、operator delete
            _pInstance = nullptr;
        }
    }
private:
    Singleton() 
    {
        cout << "Singleton()" << endl;
    }
    ~Singleton() 
    {
        cout << "~Singleton()" << endl;
    }
private:
    static Singleton *_pInstance;
};

/* Singleton *Singleton::_pInstance = nullptr; //饱汉模式(懒汉模式)*/
Singleton *Singleton::_pInstance = getInstance();//饿汉模式

pthread_once形式

//4、pthread_once,平台相关性的函数
class Singleton
{
public:
    static Singleton *getInstance()
    {
        pthread_once(&_once, init);
        return _pInstance;
    }
    
    static void init()
    {
        _pInstance = new Singleton();
        atexit(destroy);
    }
    
    static void destroy()
    {
        if(_pInstance)
        {
            delete _pInstance;//1、调用析构函数 2、operator delete
            _pInstance = nullptr;
        }
    }
    
private:
    Singleton() 
    {
        cout << "Singleton()" << endl;
    }
    
    ~Singleton() 
    {
        cout << "~Singleton()" << endl;
    }
    
private:
    static Singleton *_pInstance;
    static pthread_once_t _once;
};

Singleton *Singleton::_pInstance = nullptr; //饱汉模式(懒汉模式)
/* Singleton *Singleton::_pInstance = getInstance();//饿汉模式 */
pthread_once_t Singleton::_once = PTHREAD_ONCE_INIT;

单例模式

# 单例模式

# 什么是单例模式

# 为什么需要单例模式

# 线程安全

# 什么是线程安全？

# 如何保证线程安全？

# 单例类的特点

# 单例模式分类

# 懒汉式

# 饿汉式

# 单例模式实现

# 普通懒汉式单例（线程不安全）

# 加锁的懒汉式单例（线程安全）

# 方法1：返回普通指针

# 方法2：返回智能指针

# 静态局部变量的懒汉单例（C++11线程安全）

# 饿汉式单例（线程安全）

# 使用 C++11 std::call_once 实现单例（C++11线程安全）

# 单例模式的自动释放

# 可以使用友元形式进行设计

# 内部类加静态数据成员形式

# atexit方式进行

# pthread_once形式

单例模式

什么是单例模式

为什么需要单例模式

线程安全

什么是线程安全？

如何保证线程安全？

单例类的特点

单例模式分类

懒汉式

饿汉式

单例模式实现

普通懒汉式单例（线程不安全）

加锁的懒汉式单例（线程安全）

方法1：返回普通指针

方法2：返回智能指针

静态局部变量的懒汉单例（C++11线程安全）

饿汉式单例（线程安全）

使用 C++11 std::call_once 实现单例（C++11线程安全）

单例模式的自动释放

可以使用友元形式进行设计

内部类加静态数据成员形式

atexit方式进行

pthread_once形式