设计模式之-单例模式

单例模式，只能创建一个对象（以下示例是懒汉模式）

确保一个类只有一个实例，并提供一个访问本类实例唯一的全局访问点。单例模式的使用是当我们的系统中某个对象只需要一个实例的情况。

        public class Singleton//单例模式
        {
            // 定义一个静态变量来保存类的实例
            private static Singleton uniqueInstance;
            //定义一个标识确保线程同步
            private static readonly object locker = new object();
            // 定义私有构造函数，使外界不能创建该类实例
            private Singleton()
            {    }
            
            public static Singleton GetInstance()
            {
                 // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
                // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
                 // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
                 // 双重锁定只需要一句判断就可以了
                if (uniqueInstance == null)
                {
                    lock(locker)
                    {
                         // 如果类的实例不存在则创建，否则直接返回
                           if (uniqueInstance == null)
                           {
                                uniqueInstance = new Singleton();
                           }
                    }                   
                }
                return uniqueInstance;
            }
        }

为什么会有2个uniqueInstance？
当uniqueInstance为null，并且同时有2个线程调用GetInstance（）方法时，它们都将通过uniqueInstance==null的判断。然后由于lock机制，这两个线程则只有一个进入，另一个在外面等待，必须要其中的一个进入并出来后，另一个才能进入。而此时如果没有第二重的instance是否为null的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这就没有达到单例的目的。

---

上述介绍的单例模式是线程安全的，如果没有这方面的需求可以使用另外一种。

class Singleton
{
    private static Singleton instance;
    private Singleton//堵死了外界利用new来创建此类实例的可能
    {}
    public static Singleton GetInstance()
    {
        if(instance==null)
        {
            instance=new Singleton();
        }
        return instance;
    }
}

 在WPF中使用单例模式需要注意!!!。xaml页面本身是没有IsDispose属性的，参考下面这篇博文

WPF 单例窗口 - 苏州城外的微笑 - 博客园 (cnblogs.com)

 

        protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
        {
            this.Hide();//主要关注的是这里，关闭子页面时是隐藏，而不是销毁
            e.Cancel = true;
        }

 

 

---

以下开始介绍如何利用C++实现的单例模式：

饿汉模式：唯一实例在主函数运行之前产生。

class Singleton0
{
public:
    static Singleton0* Getinstance()
    {
        return &instance;
    }
private:
    static Singleton instance;
    Singleton0() {}
    Singleton0(const Singleton0&) = delete;
    Singleton0& operator=(const Singleton0&) = delete;
};
Singleton0 Singleton0::instance;

 

 模式的单例模式唯一的实例是在主函数运行之前就产生了，

懒汉模式：唯一实例在使用时才产生，以下为线程安全的模式，利用了mutex互斥锁

#include<iostream>
#include<mutex>
using namespace std;
mutex some_mutex;
class Singleton
{
private:
    Singleton() {}
    
    static Singleton* instance;//
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton* GetInstance()
    {
        if (instance == nullptr)
        {
            lock_guard<std::mutex> lck(some_mutex);
            if (instance == nullptr)
            {
                instance = new Singleton();
            }
            
        }
        return instance;
    }

};
Singleton* Singleton::instance = nullptr;
int main()
{
    Singleton* a0 = Singleton::GetInstance();
    Singleton* a1 = Singleton::GetInstance();
    Singleton* a2 = Singleton::GetInstance();
    cout << a0 << endl;
    cout << a1 << endl;
    cout << a2 << endl;
}

 

参考博客：

1.(1条消息) C++11线程中的几种锁_GoodLinGL的博客-CSDN博客_c++线程锁

2.(1条消息) C++单例模式的实现（懒汉式、饿汉式）_YY_Song 's blogs-CSDN博客_c++ 单例模式实现