设计模式-单例模式

前天去面试，被问到单例模式，面试官问的很详细，所以在这里写一写对单例模式的总结和看法。

单例模式作为大部分人第一个知道的设计模式广为人知，即在一个系统中有唯一存在的实例。

这样做的好处：1，确保全局唯一单例可以减少系统开销，比如系统中有较大的占用的时候，可以在启动阶段生成一个实例。例如windows系统中的任务管理器，一般来说并不能打开多个。2，在共享资源的访问或者使用，可以节省开销。比如日志文件，应用的配置等。3，由于存在唯一实例，访问对象的速度加快，比如线程池，数据库连接池。

下面针对面试官的提问回顾下单例的一些细节：

1，如何保证一个类中只存在一个实例，别人无法新new一个？

保证一个类中存在一个实例，可以使用static 甚至 static final 去修饰存在的实例和返回方法。static的好处是JVM只会为它申请一次内存空间，这样确保全局唯一。而实例变量，跟随实例共生共存，不能保证唯一性。static修饰方法，因为static方法在类初始化的时候实现了，不依赖任何实例，所以来保证唯一性。如果不想让其他人new一个实例，可以从构造函数入手，构造函数private修饰使得其他人无法创建新的实例。

2，如何避免反射new一个新的实例？

如果只有private构造方法和static修饰变量，还是可以用反射去获取新的实例。杜绝这种现象可以使用枚举Enum去实现单例模式。这里面其实并不复杂，是因为枚举中对反射进行了限制，反射会直接抛出异常：

 3，单例模式有各种实现方式，其中有没有带来的问题或者缺点？

单例模式有各种实现方式比如：饿汉式，懒汉式，内部类实现，双锁等等。

饿汉式：

public class Singleton{
    //private constructed function
    private Singleton(){}
    //Static or Static final instance
    private Static Singleton instance = new Singleton();
    //static return method
    public Singleton getInstance{
        return instance;
    }
}
    

这样做的方式可以保证线程安全，整体看起来也比较简单。但是有可能资源浪费和不能延迟加载，也就是类初始化的时候就创建了一个新的对象。

如果杜绝浪费的话就有了懒汉式： 

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

这样杜绝了浪费，只有使用的时候才生成新的实例，可以实现延迟加载。但是这样做有一个问题就是线程不安全。如果两个线程同时访问到了if语句，都得到true，会同时执行生成新的实例。在这种情况下我们可以加锁也就是双重检查锁模式：

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

这样就解决了线程安全问题，但是这样有可能因为JVM的指令重排序带来问题。在对instance初始化的时候对指令进行了重排：1，分配内存空间。

                                                2，构造，初始化对象属性。

                                                3，创建引用指向内存空间。

重排后1，3. 然后此时切换到了另一个线程，判断instance为not null 因为已经有了还没有属性，就直接拿走，但是并不能使用。

防止指令重排序可以使用volatile修饰instance。

volatile修饰后的变量具有内存可见性和防止指令重排序两个特征，lock和sychornized也可以防止指令重排。

但是加锁必定会影响执行效率，所以内部类是一个很好的解决办法：

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

但是这样还是可以反射创建新的实例，为了杜绝这种情况，可以使用枚举：

public enum Singleton{
    INSTANCE;
}