单例模式

https://www.cnblogs.com/abcdwxc/archive/2007/10/30/942834.html

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例，即提供一个访问他的全局访问点。

• 静态Singleton实现（推荐）

public class Static_Singleton {
 
   //创建 Static_Singleton 的一个对象
    public static readonly Static_Singleton instance = new Static_Singleton();
 
   //让构造函数为 private，这样该类就不会被实例化
   private Static_Singleton(){}
   }
}

//从Static_Singleton中获取唯一的对象
public class SingletonPatternDemo {
   public static void main(String[] args) {
      //获取唯一可用的对象
      Static_Singleton object = Static_Singleton.instance;
   }
}

• 单线程Singleton实现

class SingleThread_Singleton
{
    private static SingleThread_Singleton instance = null;
    private  SingleThread_Singleton(){}
    public static SingleThread_Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new SingleThread_Singleton();
            }
            return instance;
        }
    }
}

• 多线程Singleton实现

class MultiThread_Singleton
//volatile 保证严格意义的多线程编译器在代码编译时对指令不进行微调。
//如果去掉这个关键字，还是有可能发生线程不是安全的。
private  static volatile MultiThread_Singleton instance = null;
private static object lockHelper = new object();
private MultiThread_Singleton() { }
public static MultiThread_Singleton Instance
{
    get
    {
        if (instance == null)
        {
            lock (lockHelper)
            {
                if (instance == null)
                {
                    instance = new MultiThread_Singleton();
                }
            }
        }
        return instance;
    }         
}

• 饿汉式

public class Singleton {  
private static Singleton instance = new Singleton();  
private Singleton (){}  
public static Singleton getInstance() {  
return instance;  
}  
}

public class SingletonPatternDemo {
   public static void main(String[] args) {
      //获取唯一可用的对象
      Singleton object = Singleton.getInstance();
   }
}

优点：

• 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。