单例模式

1、饿汉式：

/**
 * 饿汉式
 * 若一个类的成员都是比较重的资源，这种方式不合适
 */
//不允许被继承
public final class Singleton {
 
    //定义实例变量的时候直接初始化
    //instance被ClassLoader 加载后很长一段时间才被使用，它所开辟的堆内存会驻留更久
    private static Singleton instance = new Singleton();
 
    //私有构造函数，不允许外部new
    private Singleton(){
 
    }
 
    //无法进行懒加载
    public static Singleton getInstance(){
        return instance;
    }
}

以上代码中instance作为类变量在初始化的过程中会被收集进<clinit>()方法中，该方法能够确保同步，也就是说instance在多线程的情况下不可能被实例化两次，只是instance被ClassLoader 加载后很长一段时间才被使用，instance实例所开辟的堆内存会驻留更久。饿汉式的单例设计模式可以保证多个线程下的唯一实例。

2、懒汉式：

/**
 * 懒汉式
 * 实用类实例变量的时候再去创建
 */
public final class Singleton {
 
    //定义实例,不初始化
    private static Singleton instance = null;
 
    //私有构造函数，不允许外部new
    private Singleton(){
 
    }
 
    //可保证实例的懒加载，但无法保证实例的唯一性
    public static Singleton getInstance(){
        if(null == instance)
            instance = new Singleton();
        return instance;
    }
}

以上代码中Singleton.class被初始化时instance并没有被实例化，getInstance()会判断instance是否被实例化，但是放在多线程的环境下进行分析，若有两个线程同时看到instance为null，那么instance将无法保证单例的唯一性。

3、懒汉式+同步方法

/**
 * 懒汉式+同步方法
 * 
 */
public final class Singleton {
 
    //定义实例,不初始化
    private static Singleton instance = null;
 
    //私有构造函数，不允许外部new
    private Singleton(){
 
    }
 
    //向getInstance()加入同步控制，每次只能有一个线程进入
    public static synchronized Singleton getInstance(){
        if(null == instance)
            instance = new Singleton();
        return instance;
    }
}

这里instance其实就是共享资源（数据），当多个线程访问时，需要保证数据的同步性，这种方式满足了懒加载又能保证instance实例的唯一性，但是synchronized的排他性导致getInstance()只能在同一时刻被一个线程访问，性能地下。

4、Double-Check

/**
 * Double-Check
 * 高效的数据同步策略，首次初始化时加锁，之后允许多个线程同时进行getInstance调用来获得实例
 */
public final class Singleton {
 
    //定义实例,不初始化
    private static Singleton instance = null;
 
    Connection conn;
 
    Socket socket;
 
    //私有构造函数，不允许外部new
    private Singleton(){
        this.conn;//初始化conn
        this.socket;//初始化socket
    }
 
    public static Singleton getInstance(){
        //当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
        if(null == instance) {
            synchronized (Singleton.class){
                //判断如果instance为null时创建
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

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

这种方法既满足了懒加载，又保证了instance实例的唯一性，可以允许多个线程同时对getInstance进行访问，但在多线程的情况下可能会引起空指针。

原因：
由于java实例化一个对象的操作（new）不是原子性的。所以在线程a 在执行到 代码  3 处时，当3完成了一部分时，instance就已经非null了，

    但是此时实例对象并没有构造完成。假如这个时候线程b进来if语句就会得道instance不是null， 会直接拿到未完成的 instance，从而导致空指针。

说明：

java创建一个对象，在java虚拟机上会进行以下三步操作

1、给instance分配内存

2、调用构造方法 初始化

3、指向内存分配区域

这里牵涉到一个重排序的问题。也就是123的执行顺序是随机的。而其中的3执行完后对象就不为null了

所以当3在2的前面执行时，当2执行完3还未执行时，其他线程进来就会返回未执行3的实例对象，从而导致空指针

5、volatile+Double-Check

/**

• volatile+Double-Check
• 高效的数据同步策略,volatile可以防止指令重排序

*/
public final class Singleton {

//定义实例,不初始化
private volatile static Singleton instance = null;

//私有构造函数，不允许外部new
private Singleton(){

}

public static Singleton getInstance(){
    //当instance为null时，进入同步代码块，同时可避免了每次都需要进入同步代码块，可提高效率
    if(null == instance) {
        synchronized (Singleton.class){
            //判断如果instance为null时创建
            if(null == instance){
                instance = new Singleton();
            }
        }
    }
    return instance;
}

}
这种方式满足多线程下的单例、懒加载以及获取实例的高效性。

6、Holder方式

/**
 * Holder方式
 * 借助类加载的特点，单例设计的最好方式之一
 */
public final class Singleton {
 
    //私有构造函数，不允许外部new
    private Singleton(){
 
    }
 
    //在静态内部类中持有Singleton的实例，并且可直接被初始化
    private static class Holder{
        
        private static  Singleton instance = new Singleton();
    }
    
    //调用getInstance方法，事实上获得Holder的instance静态属性
    public static Singleton getInstance(){
        return Holder.instance;
    }
}

在Singleton初始化的过程中不会创建Singleton的实例，静态内部类Holder中定义了Singleton的静态变量，并直接实例化，当Holder被主动引用时会创建Singleton的实例，Singleton实例的创建在Java编译时期收集在<clinit>()中，该方法又是同步方法，可以保证内存的可见性、JVM指令的顺序性以及原子性。

7、枚举方式

/**
 * 枚举方式
 * 枚举类型不允许被继承，同时是线程安全且只能被实例化一次
 * 
 */
public enum Singleton {
 
    INSTANCE;
    
    Singleton(){
        System.out.println("INSTANCE will be initialized immediately");
    }
 
    private static void method(){
 
       //调用该方法会主动使用Singleton,INSTANCE将会被实例化
    }
 
    //调用getInstance方法，事实上获得Holder的instance静态属性
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

枚举类型不允许被继承，同时是线程安全且只能被实例化一次，但是枚举类型不能够懒加载，对Singleton主动使用，如滴啊用其中的静态方法INSTANCE会立即实例化，可对其进行改造，增加懒加载的特性，类似于Holder方式：

/**
 * 类似于Holder方式
 * 枚举类型不允许被继承，同时是线程安全且只能被实例化一次
 *
 */
 
public class Singleton{
 
    private Singleton(){
 
    }
 
    //使用枚举充当holder
    private enum EnumHolder {
 
        INSTANCE;
 
        private Singleton instance;
 
        EnumHolder(){
            this.instance = new Singleton();
        }
 
        public Singleton getSingleton(){
            return instance;
        }
    }
 
    public static Singleton getInstance(){
        return EnumHolder.INSTANCE.getSingleton();
    }
}

原文链接：https://blog.csdn.net/LuuvyJu...