.NET 单例模式 代码

.NET 单例模式 代码

一、饿汉式：

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

类装载的时候就完成了实例化，避免了线程同步的问题；缺点在于类装载的时候就完成了实例化，没有达到懒加载的效果；如果一直未使用该实例，就造成了内存浪费。

静态代码块式写法：

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

二、懒汉式：

线程不安全式写法：

public class Singleton {
    private static Singleton singleton;
     
    private Singleton(){}
     
    public static Singleton getInstance(){
        if(singleton == null){  //多线程进入会产生多实例
            singleton = new Singleton();
        }
        return singleton;
    }
}
 
public class Singleton {
    private static Singleton singleton;
     
    private Singleton(){}
     
    public static  Singleton getInstance(){
        if(singleton == null){  //多线程进入会产生多实例
            synchronized (Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

线程安全式写法(但效率太低)：

public class Singleton {
    private static Singleton singleton;
     
    private Singleton(){}
     
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

三、双重检查式(又名double-check)：

public class Singleton {
    private static volatile Singleton singleton;
     
    private Singleton(){}
     
    public static  Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

两个if判断，第二次if判断会跳过if代码块，直接return 实例化对象;优点不仅线程安全，而且延迟加载，效率更高。缺点不能防止被反序列化，生成多个实例。

扩展思考1：为什么要double-check? 去掉第二次的check行不行呢?

思考：两个线程同时调用getInstance方法，并且由于singleton是空的，所以两个线程都可以通过第一重的if判断，然后由于锁机制的存在，会有一个线程先进入同步语句，并进入第二重的if判断，而另一个线程就会在外面等待，不过当第一个线程执行完 new Singleton() 语句后，就会退出 synchronized 保护的区域，如果没有第二重singleton == null的话，那么第二个线程也会创建一个实例，这就破坏了单例;如果第一check去掉，那么所有线程都会串行执行，效率低下，所以两个check都需要保留的。

扩展思考2：为什么要加volatile关键字?

思考：主要在于singleton = new Singleton() 不是原子操作。防止了JVM中重排序的发生，避免了1->3->2顺序执行过程中拿到未完成初始化的对象。

在JVM中代码执行步骤：

1)给singleton分配初始空间;

2)调用Singleton的构造函数等来初始化singleton;

3)将singleton对象指向分配的内存空间(执行完这步singleton就不是 null 了)。

由于JVM中存在重排序现象，执行熟悉存在 1->3->2 或者 1->2->3

四、静态内部类式：

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

和饿汉式机制类似，采用类装载机制，来保证我们初始化实例时只有一个线程，所以JVM保证了线程的安全性;不会在类装载时实例化，而是在需要调用时实例化。优点不仅线程安全，而且延迟加载，效率更高。缺点不能防止被反序列化，生成多个实例。

五、枚举式（最佳方式）：

public class EnumSingleton {
     
    INSTANCE;
     
    public EnumSingleton getInstance(){
       return INSTANCE;  
    }
}

1、写法简单，代码短小精悍，代码更简洁更优雅;

2、线程安全有保证，枚举中的各个枚举项都是通过static代码来定义和初始化的，他们会在类被加载时完成初始化，而Java类的加载由JVM保证线程安全，所以创建一个Enum 类型的枚举是线程安全的。

3、防止单例破坏，java专门对枚举序列化做了规定，在序列化是仅仅是将枚举对象的name属性输出到结果中，在反序列化时，就是通过java.lang.Enum的valueOf来根据名字查找对象，而不是新建一个新的对象，所以防止了反序列化。