单例模式

2018-10-09

Java中单例(Singleton)模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。

单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。

本文总结了五种Java中实现单例的方法，其中前两种都不够完美，双重校验锁和静态内部类的方式可以解决大部分问题，平时工作中使用的最多的也是这两种方式。枚举方式虽然很完美的解决了各种问题，但是这种写法多少让人感觉有些生疏。

方式 -----------------优点 ----------------------缺点
饿汉式 线程安全, 调用效率高 不能延迟加载
懒汉式 线程安全, 可以延迟加载 调用效率不高
双重检测锁式 线程安全, 调用效率高,可以延迟加载 -
静态内部类式 线程安全, 调用效率高,可以延迟加载 -
枚举单例 线程安全, 调用效率高 不能延迟加载

饿汉模式

饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在。
它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。
它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。
这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况。但是，如果单例占用的内存比较大，或单例只是在某个特定场景下才会用到，
使用饿汉模式就不合适了，这时候就需要用到懒汉模式进行延迟加载。

public class SingletonOne {

    private static SingletonOne singletonOne = new SingletonOne();

    private SingletonOne(){}

    public static SingletonOne NewInstance(){
        return singletonOne;
    }

}

懒汉式

懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。
如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。

public class SingletonTwo {

    private static SingletonTwo singletonTwo = null;

    private SingletonTwo(){}

    /**
     * 线程安全
     */
    public static synchronized SingletonTwo NewInstanceOne(){
        if (singletonTwo == null){
            singletonTwo = new SingletonTwo();
        }
        return singletonTwo;
    }


    /**
     * 线程不安全的
     */
    public static SingletonTwo NewInstanceTwo(){
        if (singletonTwo == null){
            singletonTwo = new SingletonTwo();
        }
        return singletonTwo;
    }

}

双重校验锁

加锁的懒汉模式看起来即解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美。
synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了。

public class SingletonThree {

    private static volatile SingletonThree singletonThree = null;

    private SingletonThree(){}

    public static SingletonThree NewInstance(){
        if ( singletonThree == null){
            synchronized (SingletonThree.class){
                if (singletonThree == null){
                    singletonThree = new SingletonThree();
                }
            }
        }

        return singletonThree;
    }
}

静态内部类

它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。不一样的是，它是在内部类里面去创建对象实例。
这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。
也就是说这种方式可以同时保证延迟加载和线程安全。

public class SingletonFour {

    private static class Singleton{
        public static SingletonFour singletonFour = new SingletonFour();
    }

    private SingletonFour(){}

    public static SingletonFour newInstance(){
        return Singleton.singletonFour;
    }
}

枚举

使用枚举除了线程安全和防止反射调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。

enum Singleton1{
    INSTANCE;

    public void show(){
        System.out.println("枚举");
    }
}
public class Enum {
    public static void main(String[] args) {
        Singleton1 singleton = Singleton1.INSTANCE;
        singleton.show();
    }
}