几种常见的单例模式设计方法

饿汉式

package com.Thread.chapter14;

/**
 * Description
 *
 * @Author: xuxin
 * @Date: 2020/5/3 14:59
 * @Version 1.0
 */
//final不允许被继承
public final class Singleton {
    //实例变量
    private byte[] bytes = new byte[1024];

    //d定义实例变量初始化
    private static Singleton instance = new Singleton();

    //私有构造函数
    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }

    public static void main(String[] args) {

    }

}

饿汉式单利设计模式。
关键在于instance类变量直接进行了初始化，如果直接使用Singleton类，其内部变量会保证直接初始化，instance作为类变量在类初始化的过程中会被收集进()
方法中，该方法能保证百分之百同步，也就是说instance在多线程情况下不会被实例化两次，但是instance被ClassLoader加载后很长一段时间才被使用，意味着instance实例所开辟的堆内存空间
会驻留更久的时间。
如果类成员属性较少，，且占用的内存资源不多，使用饿汉式未尝不可。如果累成员较多，这种方式有些不妥。
适合用于单线程、多线程

懒汉式

//final不允许被继承
public final class Singleton {
    //实例变量
    private byte[] bytes = new byte[1024];

    //d定义实例变量初始化
    private static Singleton instance = null;

    //私有构造函数
    private Singleton() {
    }

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

Singleton类变量instance为null，因此当Singleton.class被实例化之后，instance并不会被实例化，getInstance()会判断instance会不会实例化。
看起来没什么问题，但是在多线程的情况下，两个线程可能同时遇到instance=null 的状态，他们会分别进行初始化，instance可能会被实例化2次以上，并不能保证单利的唯一性。

懒汉式+同步方法

懒汉式+同步方法

//final不允许被继承
public final class Singleton {
    //实例变量
    private byte[] bytes = new byte[1024];

    //d定义实例变量初始化
    private static Singleton instance = null;

    //私有构造函数
    private Singleton() {
    }

    //同步方法，每次只有一个线程进入到方法中，
    public  static synchronized Singleton getInstance() {
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

能保证instance被实例化一次，但是性能低下，synchronized关键字天生的排他性导致了getInstance方法只能在同一时刻被一个线程访问，性能低下。

Double-Check

ouble-Check
高效的数据同步策略，那就是首次初始化时加锁，之后允许多个多线程同步进行getInstance()方法调用来获取类的实例

//final不允许被继承
public final class Singleton {
    //实例变量
    private byte[] bytes = new byte[1024];

    //d定义实例变量初始化
    private static Singleton instance = null;

    Connection conn;
    Socket socket;

    //私有构造函数
    private Singleton() {
    }

    //同步方法，每次只有一个线程进入到方法中，
    public  static synchronized Singleton getInstance() {
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

当只有instance=null成立时，只有一个线程能够进入到同步代码块，完成对instance的实例化，随后的线程发现null=instance 不成立无需进行任何动作，
以后对getInstance的访问就不需要数据同步的保护。

这种方式既能满足懒加载、保证instance实例的唯一性，Double-Check方式提供了高效的数据同步策略，允许多线程同时对getInstance()进行访问，但是在多线程情况下可能会产生空指针异常NullPointerException NPE.

Reason: 原因是需要对Connection和Socket进行初始化，还有Singleton,根据JVM运行时指令重排序和Happens-Before 规则，这三者之间的实例化顺讯并无前后关系约束，

线程1–> instance=null满足 线程1获得锁，创建instance实例，创建conn实例，创建socket实例
线程2判断到instance不为null，即可返回并且使类的实例变量conn和socket，但是不幸的是此时conn和socket还未创建完成。

Volatile +Double-Check

Volatile可以防止重排序的发生，稍加修改可满足单利、懒加载、以及获取实例的高效性
private volatile static Singleton instance = null;

Holder方式

//final不允许被继承
public final class Singleton {
    //实例变量
    private byte[] bytes = new byte[1024];

    //d定义实例变量初始化
    private volatile static Singleton instance = null;

    Connection conn;
    Socket socket;

    //私有构造函数，初始化逻辑
    private Singleton() {
        this.conn = null;
        this.socket = null;
    }

    //同步方法，每次只有一个线程进入到方法中，
    public static Singleton getInstance() {

        return HOLDER.instance;
    }

    private static class HOLDER {
        private static Singleton instance = new Singleton();
    }
}

在Singleton中并没有instance的静态成员，而是将其放入到静态内部类Holder之中，HOLDER被引用之后才会创建Singleton实例

枚举方式

public class Singleton {
    //实例变量
    private byte[] bytes = new byte[1024];

    private enum EnumHolder {
        INSTANCE;
        private Singleton instance;

        EnumHolder() {
            this.instance = new Singleton();
        }

        private Singleton getSingleton() {
            return instance;
        }

    }

    public static Singleton getInstance() {
        return EnumHolder.INSTANCE.getSingleton();
    }

}

枚举的方式实现单例模式，枚举类型不允许被继承，同样是线程安全的且只能被实例化一次，可以实现懒加载

总结：在设计单例程序的时候未必能满足单实例、懒加载以及高性能等特点。一般经常会用到Holder和枚举方式设计单例。
来源：《Java高并发编程详解》-汪文君