设计模式-单例模式

顾名思义，单例模式就是指在当前进程中，通过单例模式创建的类有且只有一个实例。

特点：

1. 在Java应用中，单例模式能保证在一个JVM中，该对象只有一个实例存在
2. 构造器必须是私有的，外部类无法通过调用构造器方法创建该实例
3. 没有公开的set方法，外部类无法调用set方法创建该实例
4. 提供一个公开的get方法获取唯一的这个实例

优点：

1. 省去了new操作符，降低系统内存的使用频率，减轻GC压力
2. 避免对资源的重复占用
3. 系统中某些类，如spring里的controller，控制着处理流程，如果该类可以创建多个的话，系统完全乱了
4. 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销

1. 饿汉模式

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

这种模式提前把对象new出来，这样在获取这个类的对象的时候直接就存在一个类了，省去了创建类这一步的开销。

2. 懒汉模式（线程不安全）

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

懒汉模式声明了一个静态对象，在用户第一次调用的时候进行初始化，但是第一次加载的时候需要实例化，所以比饿汉模式反映稍慢一些，而且多线程不能正常工作。

3. 懒汉模式（线程安全）

如果有两个线程同时调用懒汉模式的单例模式，如果当线程1当第一个线程在执行if（instance == null）时，此时instance是为null的进入语句，在还没有执行instance=new Singleton()时（此时instance是为null的）第二个线程也进入了if(instance == null)这个语句，因为之前进入这个语句的线程中还没有执行instance=new Singleton()，所以它会执行instance = new Singleton()来实例化Singleton对象，这样会导致出现两个实例化的对象，所以得在判断语句那里加锁。

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

上述这种写法是一种简单粗暴的写法，在每次创建实例时，先锁起来，再进行判断，这样在数据量大时，会严重降低系统的处理速度。所以，我们又想到了使用双检锁进行两次判断。

public class Singleton {
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(instance == null){
            //同步块，线程安全的创建实例
            synchronized (Singleton.class) {
                //再次检查实例是否存在，如果不存在才真正的创建实例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这种写法将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。但是上述写法还存在有一定的问题。
在Java中，创建对象和赋值操作是分开的，即instance = new Singleton();语句是分两步执行的，但是JVM并不会保证这两个步骤的先后执行顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例，也就是如果两个线程同时进入了第一个if判断语句，线程1先进入synchronized块，由于instance为null，所以它执行instance = new Singleton()，由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后线程1离开了synchronized块，线程2进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序，也就是线程2此时如果想使用实例，却发现其没有初始化，所以直接报错。

所以需要加上volatile修饰Singleton，再做一次优化。(通过volatile修饰的变量，不会被线程本地缓存，所有线程对该对象的读写都会第一时间同步到主内存，从而保证多个线程间该对象的准确性)

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(instance == null){
            //同步块，线程安全的创建实例
            synchronized (Singleton.class) {
                //再次检查实例是否存在，如果不存在才真正的创建实例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

但是由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率并不是很高,所以我们可以通过内部静态类来实现单例模式。

public class Singleton {  
  
    /* 私有构造方法，防止被实例化 */  
    private Singleton() {  
    }  
  
    /* 此处使用一个内部类来维护单例 */  
    private static class SingletonFactory {  
        private static Singleton instance = new Singleton();  
    }  
  
    /* 获取实例 */  
    public static Singleton getInstance() {  
        return SingletonFactory.instance;  
    }  
  
    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
    public Object readResolve() {  
        return getInstance();  
    }  
}  

使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。
这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕， 这样我们就不用担心上面的问题。
同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式。
还有一种更加简洁的写法，就是通过枚举实现单例模式。

public enum Singleton {
    /**
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。
     */
    Instance;
}

使用枚举来实现单实例控制会更加简洁，而且JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。