单例模式（懒汉和饿汉）——独生子女挺好

  单例模式（Singleton）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

  特点：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

  懒汉和饿汉的区别：

• 饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了；

• 而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

• 饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题；

• 懒汉式本身是非线程安全的，为了实现线程安全有双重锁定和，

---

懒汉式单例

  方法一：Synchronized() 双重锁定

    class Singleton
    {
        private static Singleton instance;
        private static readonly object syncRoot = new object();//只读

        //构造方法private，规避了外界利用new创建此类的可能
        private Singleton()
        { }

        //此方法是获得本类实例的唯一全局访问点
        public static Singleton GetInstance()
        {
        	if (instance == null)	//第一次判断是否已创建实例
        	{
        		//没有就让一条线程进入并加锁，其它线程等待，等第一条出去以后解锁，然后下一条线程再进入并加锁，直到所有线程处理完毕。
        		lock (syncRoot)		
        		{
		            if (instance == null)   //二次判断是否已创建实例
		            {
		                instance = new Singleton(); //若没有就创建一个
		            }
		        }
            }
            return instance;//否则返回已有的实例
        }
    }

  方法二：Synchronized() 方法

//Synchronized在指定的对象周围创建线程安全（同步）包装,每次执行都要同步
//无论是读和写，都要一个进行完在进行下一个
public static synchronized Singleton getInstance() 
{
    if (instance == null) 
    {  
        instance = new Singleton();
     }  
     return instance;
}

  方法三：静态类：这个我还不明白，先暂时记在这

public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
} 

---

饿汉式单例

类一加载就实例化对象，提前占用系统资源

//密封类阻止了继承，杜绝继承会增加实例的可能
public sealed class Singleton
{
	//在第一次引用类的任何成员时创建实例
	private static readonly Singleton instance = new Singleton();
	private Singleton()//构造方法私有
	{}
	public static Singleton GetInstance()
	{
		return instance;
	}
}

本文地址：https://blog.csdn.net/CharmaineXia/article/details/110916053