设计模式之单例模式

public class Singleton{
private static Singletoninstance=null;
private Singleton(){  //构造方法是private，堵死了外界用new实例化
//dosomething
}
//获取本类实例的唯一全局访问点
public static Singleton getInstance(){            
if(instance==null){  //若实例不存在，创建一个返回，否则返回已有实例
instance=new Singleton();
}
return instance;
}
}

public class Singleton{
private static Singletoninstance=null;
private Singleton(){  //构造方法是private，堵死了外界用new实例化
//dosomething
}
//获取本类实例的唯一全局访问点
public static synchronized Singleton getInstance(){            
if(instance==null){  //若实例不存在，创建一个返回，否则返回已有实例
instance=new Singleton();
}
return instance;
}
}

public class Singleton{
//在自己内部定义自己的一个实例，只供内部调用
private static Singleton instance=new Singleton();
private Singleton(){
//dosomething
}  
//这里提供了一个供外部访问本class的静态方法，可以直接访问         
public static Singleton getInstance(){
  return instance;
}
}

public class Singleton{
private static Singletoninstance=null;
private Singleton(){
//dosomething
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(null==instance){
instance=new Singleton();
}
}
}
return instance;
}
}
//这个模式将同步内容下方到if内部，提高了执行的效率，不必每次
获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。

　　public class Singleton
　　{
　　//定义一个私有的静态全局变量来保存该类的唯一实例
　　private static Singleton singleton;
//定义一个只读静态对象
　　//且这个对象是在程序运行时创建的
　　private static readonly object syncObject = new object();
/// <summary>
　　/// 构造函数必须是私有的
　　/// 这样在外部便无法使用 new 来创建该类的实例
　　/// </summary>
　　private Singleton()
　　{}
/// <summary>
　　/// 定义一个全局访问点
　　/// 设置为静态方法
　　/// 则在类的外部便无需实例化就可以调用该方法
　　/// </summary>
　　/// <returns></returns>
　　public static Singleton GetInstance()
　　{
　　//这里可以保证只实例化一次
　　//即在第一次调用时实例化
　　//以后调用便不会再实例化
//第一重 singleton == null
　　if (singleton == null)
　　{
lock (syncObject)
　　{
　　//第二重 singleton == null
　　if (singleton == null)
　　{
　　singleton = new Singleton();
　　}
　　}
　　}
　　return singleton;
　　}
　　}