单例模式 ( SingleTon )

1. 意图（Intent）

确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问方法。

单例模式要点

• 某个类只能有一个实例
• 必须自行创建这个实例

• 必须自行向整个系统提供这个实例

  单例模式优点

• 提供了对唯一实例的受控访问

• 可以节约系统资源，提高系统的性能

  单例模式缺点

• 扩展困难 ( 缺少抽象层 )

• 单例类的职责过重

2. 类图（Class Diagram）

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。
私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

3. 实现（Implementation）

I 懒汉式单例 （多线程不安全）

优点：在第一次调用的时候实例化自己，减少资源浪费

缺点：单线程下是安全的，但是多线程下不安全。

以下实现中，私有静态变量 instance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 instance ，从而节约资源。

这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if(instance==null) ，并且此时 instance为 null，那么会有多个线程执行 instance= new Singleton(); 语句，这将导致多次实例化 instance 。

public class Singleton{
    //1.静态私有成员变量
    private static Singleton instance =null;        
    //2.私有构造函数
    private Singleton(){}
    //3.静态公有的工厂方法
    public static Singleton GetInstance(){
        if(instance==null)    //此处多线程下有可能多次实例化 instance
            instance=new Singleton();
        return instance;
    }
}

🚩II 饿汉式单例 [ 线程安全、使用最完美 ]

缺点：系统一开始就会加载这个单例，即使我们整个系统使用过程中未用到它。从一定角度来说有点浪费资源。

线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。

但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。

public class Singleton{
    //1.静态私有成员变量
    private static final Singleton instance =new Singleton();        
    //2.私有构造函数
    private Singleton(){}
    //3.静态公有的工厂方法
    public static Singleton GetInstance(){
        return instance;
    }
}

III 懒汉式单例 [ 线程安全 ]

缺点：加锁高并发下的代价过高，我们只有写操作需要加锁，在读操作时是不需要加锁，但此处不论读写全加锁

为了解决多线程下的不安全，给代码加锁，保证在同一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 instance 。

但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 instance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。

写操作：当 **instance==null** 时，是需要加锁进行分配的 读操作：当 **instance !=null** 时，是不需要加锁的，应该直接返回内存地址

public class Singleton{
    //1.静态私有成员变量
    private static Singleton instance =null;        
    //2.私有构造函数
    private Singleton(){}
    //3.静态公有的工厂方法
    public synchronized static Singleton GetInstance(){
        if(instance==null){
             instance=new Singleton();
        }   
        return instance;
    }
}

IV 双重检查锁 [ 线程安全、多线程下 reorder 不安全 ]

缺点：在汇编层会出现内存 reorder 的不安全

为了解决锁的代价过大，在读操作时进行不必要的加锁，因此设计出了双重检查锁，instance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 instance 没有被实例化时，才需要进行加锁。

双重校验锁先判断 instance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。

reorder 解释 ：多线程下会读取并使用到未初始化的 instance，由于 JVM 的指令重排序
正常步骤：先分配内存，构造器初始化内存，赋值给变量

1. 先分配内存
2. 调用 Singleton 构造器，对内存初始化
3. 将分配的内存赋值给变量 instance

编译器性能优化：先分配内存，赋值给变量，构造器初始化内存

1. 先分配内存
2. 将分配的内存赋值给变量 instance
   • 多线程中另外一个人拿到的非空 instance 并没有初始化 [ reorder不安全 ]
3. 调用 Singleton 构造器，对内存初始化

   public class Singleton{
    //1.静态私有成员变量
    private static Singleton instance =null;        
    //2.私有构造函数
    private Singleton(){}
    //3.静态公有的工厂方法
    public static Singleton GetInstance(){
        if(instance==null){            //预防读操作加锁
            synchronized (Singleton.class){
                if(instance==null){    //写操作层面加锁
                     instance=new Singleton();
                }
            }   
        }
        return instance;
    }
   }

   考虑下面的实现，也就是只使用了一个 if 语句。在 instance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 instance = new Singleton(); 这条语句，只是先后的问题，那么就会进行两次实例化。

因此必须使用双重校验锁，也就是需要使用两个 if 语句：
第一个 if 语句用来避免 instance 已经被实例化之后的加锁操作
第二个 if 语句用来避免 instance 被实例化两次

if(instance==null){            //预防读操作加锁
    synchronized (Singleton.class){
        instance=new Singleton();
    }   
}

IV 正确双重检查锁 [ 关键字 volatile ]

指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。

备注：JDK 1.5 之后官方发现了这个 BUG ，为了解决上述问题，需要在 instance 前加入关键字 volatile

volatile 关键字：指令重排被禁止，所有的写（write）操作都将发生在读（read）操作之前。

public class Singleton{
    //1.静态私有成员变量
    private volatile static Singleton instance =null;    //使用 volatile 关键字
    //2.私有构造函数
    private Singleton(){}
    //3.静态公有的工厂方法
    public static Singleton GetInstance(){
        if(instance==null){            //预防读操作加锁
            synchronized (Singleton.class){
                if(instance==null){    //写操作层面加锁
                     instance=new Singleton();
                }
            }   
        }
        return instance;
    }
}

V 静态内部类

优点：

1. 确保了线程安全
2. 确保了单例的唯一性
3. 同时也延迟了单例的实例化，不浪费内存

缺点：

1. 致命缺点就是外部无法传递参数的问题

当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 GetInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

public class Singleton{
    //1.私有构造函数
    private Singleton(){}
    //2.静态内部类
    private static class SingletonHolder{
        private static final Singleton INSTANCE=new Singleton();
    }
    //3.返回函数
    public static final Singleton GetInstance(){
        return SingletonHolder.INSTANCE;
    }
}

静态内部类如何确保单例的唯一性和延迟实例化呢 ？ [ 首先明确类的加载时机 ]
Java 虚拟机有且仅有的5种场景会对类进行初始化

1. 遇到 new、getstatic、setstatic 或者 invokestatic 这4个字节码指令时，生成对应的 Java 代码场景为：使用 new 关键字实例化对象的时侯、读取或设置一个类的静态字段 ( 被 final 修饰、已在编译期把结果放入常量池的静态字段除外)、调用一个类的静态方法时。
2. 使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
3. 当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
4. 当虚拟机启动时，用户需要指定一个要执行的主类( 包含 main() 方法的类 )，虚拟机会先初始化这个类。
5. 当使用JDK 1.7等动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是”有且仅有“，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。

[ 上述文字解释了静态内部类不会被初始化 ]

我们再回头看下 GetInstance( ) 方法，没有使用 new 对象，而是调用的 SingleTonHoler.INSTANCE，故不管多少个线程去调用 GetInstance( ) 方法，取的都是同一个 INSTANCE 对象。只有当 GetInstance()方法被调用时，
SingleTonHoler 才在 SingleTon 的运行时常量池里，把符号引用替换为直接引用，这时静态对象 INSTANCE 也才真正被创建，然后再被 GetInstance( ) 方法返回出去，因此延迟了单例的实例化。

那么 INSTANCE 在创建过程中又是如何保证线程安全的呢？

在《深入理解JAVA虚拟机》中，有这么一句话：
虚拟机会保证一个类的 ( ) 方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 ( ) 方法，其他线程都需要阻塞等待，直到活动线程执行( ) 方法完毕。如果在一个类的 ( ) 方法中有耗时很长的操作，就可能造成多个进程阻塞 (其他线程虽然会被阻塞，但如果执行( )方法后，其他线程唤醒之后不会再次进入()方法。同一个加载器下，一个类型只会初始化一次 )，在实际应用中，这种阻塞往往是很隐蔽的。故而，INSTANCE 在创建过程中是线程安全的

总结：

1. 外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化 INSTANCE，故而不浪费内存。

   只有第一次调用 GetInstance( ) 方法会导致虚拟机加载SingleTonHoler类，并初始化 INSTANCE

2. GetInstance( ) 方法，内部没有使用 new 对象，保证了 INSTANCE 对象的唯一性

3. 虚拟机会保证一个类的 ( ) 方法在多线程环境中被正确地加锁、同步，确保了线程安全性

那么静态内部类单例就是最完美的单例模式了吗？

其实不然，静态内部类也有着一个致命的缺点，就是传参的问题，由于是静态内部类的形式去创建单例，故外部无法传递参数进去。

🚩VI 枚举单例 [ 语法最完美、线程安全、防反序列化 ]

优点：

1. 解决了线程安全
2. 防止反序列化

   原因：枚举没有构造函数，因此反序列化后还是同一对象

//1.定义方式
public enum Singleton{
    INSTANCE;
    public void method(){
        ....
    }
}
//2.使用方式
Singleton.INSTANCE

public enum Singleton {
    INSTANCE;
    private String objName;
    public String getObjName() {
        return objName;
    }
    public void setObjName(String objName) {
        this.objName = objName;
    }
    public static void main(String[] args) {
        // 单例测试
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());
        // 反射获取实例测试
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

枚举在 Java 中与普通类一样，拥有字段与方法，而且枚举实例创建是线程安全的，任何情况下，都是一个单例。

该实现可以防止反射攻击。在其它实现中，通过 **setAccessible()** 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。但是枚举实现是由 JVM 保证它只会实例化一次，因此不会出现上述的反射攻击。

该实现在多次序列化和序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法 。

4. 例子（Examples）

• Logger Classes
• Configuration Classes
• Accesing resources in shared mode
• Factories implemented as Singletons

5. JDK

• java.lang.Runtime#getRuntime()
• java.awt.Desktop#getDesktop()
• java.lang.System#getSecurityManager()