Java设计模式一单例模式

一、为什么用单例模式

单例模式是保证类只有一个实例，并提供一个访问该实例的全局节点。我认为，解决了以下三个问题：

1、只创建一个实例，避免了空间的浪费。
2、提高了创建对象的速度。相比于new一个新的实例，每次都返回同一个对象显然是更快的。
3、可以避免多实例创建出现的逻辑问题。

二、四种单例模式

1、饿汉式单例模式

饿汉式单例模式的主要特点是：线程安全，调用效率高，不可延时加载。

class SingletonHungry{

    private static  SingletonHungry INSTANCE = new SingletonHungry();

    private SingletonHungry(){
    }

    private  static  SingletonHungry getInstace(){
        return INSTANCE;
    }

}

为什么叫做饿汉式单例模式呢？在类初始化一开始就迫不及待地初始化实例，就像饿了好几天的大汉急着吃饭一样，所以这种创建单例的方式叫做饿汉式单例模式。
（1）类初始化时，是一个天然的线程安全环境，在此时立刻创建对象，是线程安全的。
（2）对象提前创建好，调用效率高。
（3）由于饿汉式单例模式在类初始化时立刻加载，所以不可延时加载。

2、懒汉式单例模式

懒汉式单例模式的主要特点是：线程安全，调用效率低，可延时加载。接下来，通过简单的Demo介绍下：

class SingletonLazy{

    private static  SingletonLazy INSTANCE ;

    private SingletonLazy(){
    }

    private  static  SingletonLazy getInstace(){
        if (INSTANCE == null){
            INSTANCE = new SingletonLazy();
        }
        return INSTANCE;
    }
}

为什么叫做懒汉式单例模式呢？在类初始化一开始没有初始化实例，而是慢慢地等到真正要获取实例的时候才去做初始化。很佛系，就像一个慵懒的大汉一样，所以这种创建单例的方式叫做懒汉式单例模式。

（1）线程不安全。可能多个线程同时创建对象。
（2）节省资源。真正用到的时候才创建实例，避免提前创建但可能没被使用浪费资源。

（3）运行效率低。对象没有提前创建好，且每次都需要判空。

3、双重检测锁单例模式

上面的懒汉式单例模式，我们提到了线程不安全。那么为了解决懒汉式单例模式的线程安全问题，诞生了双重检测锁单例模式。

class SingletonDoubleCheck{
    //volatile 解决指令重排问题
    private static volatile SingletonDoubleCheck INSTANCE ;

    private SingletonDoubleCheck(){
    }

    private  static  SingletonDoubleCheck getInstace(){
       
        if (INSTANCE == null){ //第一次
            synchronized(SingletonDoubleCheck.class){
                if (INSTANCE == null){//第二次
                    INSTANCE = new  SingletonDoubleCheck();
                }
            }
        }
        return INSTANCE;
    }

}

这其实是一种优化后的双重检测锁，使用volatile解决指令重排问题。跟懒汉式单例模式相比，解决了线程安全问题。但是，代码较为繁琐且运行效率更低，毕竟又加锁又双重检测。因此，不推荐使用该方式。

4、静态内部类单例模式

以上的单例模式各有优缺点，截止到目前，最好的看上去应该是饿汉式。但存在不能延迟加载的问题，可能导致资源浪费。有没有更好的单例模式呢？有，那就是静态内部类单例模式。在具备饿汉式单例模式优点的同时，又可延迟加载。：

class SingletonOutClass{
   
    private SingletonOutClass(){
    }
    private static  class SingletonInerClass{
        private static final   SingletonOutClass INSTANCE = new SingletonOutClass();
    }

    private  static  SingletonOutClass getInstace(){
        return SingletonInerClass.INSTANCE;
    }

}

外部类​​​​​​​加载时，并不需要立即加载静态内部类，静态内部类不被加载则不去初始化INSTANCE ，实现了懒加载。

5、枚举单例模式

以上四种单例模式，其实都存在一个隐藏的问题，那就是反射对单例的破坏。枚举单例模式可以防止反射去创建实例。但实际上可能用的不多

public enum SingletonEnum {
    INSTANCE;
    public SingletonEnum getInstace() {
        return INSTANCE;
    }

}

最后，总结一下：双重检测锁和懒汉式单例模式我们基本可以考虑不去使用。饿汉式是最简单的，在不考虑可能的资源浪费的情况下，可以去使用。更推荐静态内部类，因为完美解决了所有的问题。当然，如果你对反射有要求，那只能选择枚举了。