signed

QiShunwang

“诚信为本、客户至上”

单例模式

2020/12/26 21:28:43   来源:

目录

一、定义:

二、特点:

三、优点:

四、缺点:

五、实现:

六、饿汉单例和懒汉单例区别


一、定义:

保证一个类仅有一个实例,并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个最好的办法就是,让类自身负责保存他的唯一实例。这个类可以保证没有其他实例可以被创建,并且它可以提供一个访问该实例的方法。

 

二、特点:

1.保证唯一实例对象;

2.该单例对象必须由单例类自行创建;

3.单例类对外提供一个访问该单例的全局访问点;

image.png

 

三、优点:

1.保证唯一的实例化

2.单例模式因为Singleton类封装它的唯一实例,这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问

 

四、缺点:

1.单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则;

2.单例模式一般没有接口,扩展困难。如果要扩展,则除了修改原来的代码,没有第二种途径,违背开闭原则;

3.单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则

 

五、实现:

①、单例模式

//Single类,定义一个GetInstance操作,允许客户访问它的唯一实例。GetInstance是一个静态方法,主要负责创建自己的唯一实例
class LazySingleton
{
    //懒汉单例:在第一次被引用时,才会将自己实例化。
    private static LazySingleton instance;      //私有静态的类变量
    private LazySingleton() { }                 //私有的构造方法,防止外界能够new实例化它

    public static LazySingleton GetInstance()    //获得实例静态方法
    {
        if (instance == null)                   //判断是否有实例
        {
            instance = new LazySingleton();     //创建实例
        }
        return instance;                        //返回实例
    }
}


//客户端代码
class Program
{
    static void Main(string[] args)
    {
        Singleton s1 = Singleton.GetInstance();
        Singleton s2 = Singleton.GetInstance();
        
        if (s1 == s2)                         //比较两次实例化后对象的结果是否相同
        {
            Console.WriteLine("两个对象是相同的实例");    
        }
        Console.Read();    
    }
}

这样的话就满足了单例的效果,保证只实例化一个类,客户端通过那唯一可以访问的GetInstance方法来访问那一个实例。但如果是多个线程同时调用GetInstance方法,同时运行到了GetInstance方法这儿,它们都会去判断有没有被实例化,判断都为True,那样的话就创建了两个实例,就违背了单例模式,不是一个单例。如何解决这样一个问题呢?

 

②、多线程单例

//单例类
class MultiThreadSingleton
{
    private static MultiThreadSingleton instance;             //声明静态类变量
   
    private static readonly object syncRoot = new object();   //程序运行时创建一个静态只读的进程辅助对象
    private MultiThreadSingleton() { }                       //私有的构造方法,防止外界new实例化它

    public static MultiThreadSingleton GetInstance()         //创建实例方法
    {
        lock (syncRoot)                                      //加锁,在同一个时刻加了锁的那部分程序只有一个线程可以进入
        {
            if (instance == null)                           //判断是否创建实例
            {
                instance = new MultiThreadSingleton();      //创建实例
            }
        }
        return instance;                                     //返回实例
    }
}

//客户端代码
class Program
{
    static void Main(string[] args)
    {
        MultiThreadSingleton s1 = MultiThreadSingleton.GetInstance();   //调用单例类的GetInstance方法,获得实例
        MultiThreadSingleton s2 = MultiThreadSingleton.GetInstance();   //调用单例类的GetInstance方法,获得实例
        
        if (s1 == s2)                                 //判断两个实例是否相同
        {
            Console.WriteLine("两个对象是相同的实例");  //控制台输出结果
        }
        Console.Read();                               //读取下一个字符                  
    }
}

我们可以让最先进入的那个线程先上一把锁,创建实例。后面在进入的线程就不会再去创建对象实例了,因为第一名来的线程已经创建了,你这个判断的结果是False,自然无法创建了。这样的话就保证了多个线程同时访问的话不会有多个实例化。解决了上面单实例带来的问题。但每次进入的线程都需要先加锁在判断,我都还不知道有没有创建过这个实例呢你就让我加锁,第一名已经实例化过了,我进去再加锁,在判断一次,如果有上百个线程同时访问呢,这样的工作重复上百次,不是很影响我这个程序的性能吗?我们就可以用到双重锁定来解决这个问题

 

③、双重锁定

class MultiThreadSingleton
{
    private static MultiThreadSingleton instance;             //声明静态类变量
   
    private static readonly object syncRoot = new object();   //程序运行时创建一个静态只读的进程辅助对象
    private MultiThreadSingleton() { }                        //私有的构造方法,防止外界new实例化它

    public static MultiThreadSingleton GetInstance()          //此方法是获得本类实例的唯一全局访问点
    {
        if(instance ==null)                                   //一重:判断是否创建实例
        {
            lock (syncRoot)                                      //加锁,在同一个时刻加了锁的那部分程序只有一个线程可以进入
            {
                if (instance == null)                            //二重:判断若实例不存在,则new一个新实例,否则返回已有的实例
                {
                    instance = new MultiThreadSingleton();       //创建实例
                }
            }
         }
        return instance;                                         //返回实例
    }
}

//客户端代码
class Program
{
    static void Main(string[] args)
    {
        MultiThreadSingleton s1 = MultiThreadSingleton.GetInstance();   //调用单例类的GetInstance方法,获得实例
        MultiThreadSingleton s2 = MultiThreadSingleton.GetInstance();   //调用单例类的GetInstance方法,获得实例
        
        if (s1 == s2)                                 //判断两个实例是否相同
        {
            Console.WriteLine("两个对象是相同的实例");  //控制台输出结果
        }
        Console.Read();                               //读取下一个字符                  
    }
}

通过这样两重的判断,进入的线程不用每次都加锁,只是在实例未被创建的时候在加锁处理。同时也保证多线程的安全。

 

④、静态初始化

C#与公共语言运行库也提供了一种‘静态初始化’方法,这种方法不需要开发人员显示地编写线程安全代码,即可解决多线程环境下它是不是安全问题。也可以理解为饿汉单例。这种静态初始化的方式是在自己被加载时将自己实例化,有种迫不及待的感觉

public sealed class EagerSingleton       //组织发生派生,而派生可能会增加实例(sealed:密封的)
    {
        //在第一次引用类的任何成员时创建实例。公共语言运行库负责处理变量初始化
        private static readonly EagerSingleton instance = new EagerSingleton();    //饿汉单例:类一加载就实例化对象,提前占用系统资源
        private EagerSingleton() { } 
        public static EagerSingleton GetInstance()
        {
            return instance;
        }
    }    

 

六、饿汉单例和懒汉单例区别:

 

实例化

线程安全

懒汉单例

被引用时

不安全(通过双重锁定保障)

饿汉单例

类一加载时

安全