JAVA 7个单例模式方法

1.饿汉式

 饿汉式可以保证多线程下唯一的实例，getInstance性能也比较高，但是无法进行懒加载。

/**
*    饿汉式可以保证多线程下唯一的实例，getInstance性能也比较高，但是无法进行懒加载。
*/
public class Singleton1{

    private static Singleton1 instance = new Singleton1();

    //私有化构造函数，防止被实例化
    private Singleton1(){}

    public static Singleton1 getInstance(){
        return instance;
    }
}

2.懒汉式

懒汉式虽然实现单例的懒加载，但是在多线程下不安全的。因为线程1判断null == instance为true时,还没有* 实例化instance，切换到了线程2运行，线程2判断null == instance也为true。就会实例化多次

/**
* 懒汉式虽然实现单例的懒加载，但是在多线程下不安全的。因为线程1判断null == instance为true时,还没有* 实例化instance，切换到了线程2运行，线程2判断null == instance也为true。就会实例化多次
*/
public class Singleton2{
    
    private static Singleton2 instance = null;

    //私有化构造函数，防止被外部实例化
    private Singleton2(){}

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

}

3.懒汉式 + 同步方法（synchronized）

synchronized 控制了整个方法，容易多线程性能低下。

采用懒汉式 + 数据同步方式既满足了懒加载又能百分之百保证instance实例的唯一性，但是synchronized 关键字天生的排他性导致了getInstance方法只能在同一时刻被一个线程所访问，性能低下

public class Singleton3{
    
    private static Singleton3 instance = null;

    //私有化构造函数，防止被外部实例化
    private Singleton3(){}

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

}

4.Double-check 

double-check 有可能会引起空指针的问题。

关键点在于：根据JVM指令重排序和Happens-Before规则，这两者之间的实例化顺序并无前后关系的约束 

那么极有可能instance最先被实例化，而conn并未完成实例化，未完成初始化的实例调用其他方法将会抛出空指针异常。

public class Singleton4{

    private static Singleton4 instance = null;

    private String conn;


    //私有化构造函数，防止被外部实例化
    private Singleton4(){
        this.conn = "test";
    }

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

5.Volatile + double + check

java有用户内存和主内存的区别，对于变量以volatile 声明以保证变量在内存的可见性，即可消除这个空指针隐患

public class Singleton5{

    private static Singleton5 instance = null;

    private String conn;


    //私有化构造函数，防止被外部实例化
    private Singleton5(){
        this.conn = "test";
    }

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

6.Holer方式

即以静态内部类的方式提供示实例

该方法又是同步方法，保证了内存的可见性，JVM的顺序性和原子性。Holder方式是单例设计最好的设计之一

public class Singleton6{
    
    //静态内部类提供实例
    private static class Holder{
        private static Singleton6 instance = new Singleton6();
    } 

    public static Singleton6 getInstance(){
        return Holder.instance;
    }
}

7.枚举方法，线程安全，不能懒加载

枚举类型不允许被继承，同样是线程安全且只能被实例化一次，但是枚举不能够懒加载，对于Singleton6主动使用，比如调用其中静态方法则INSTANCE会立即得到实例化

public enum Singleton7{
    INSTANCE;

    Singleton7(){}

    public static void method(){
        //调用该方法，则会主动使用Singleton7, INSTANCE则会被实例化
    }

    public static Singleton7 getInstance(){
        return INSTANCE;
    }
}

可改造类似用Holder的方式支持懒加载

public class Singleton7_2{
    
    private Singleton7_2(){}

    private enum Holder{
        INSTANCE;
        private Singleton7_2 instance;
        
        Holder(){
            this.instance = new Singleton7_2();
        }

        public Singleton7_2 getInstance(){
            return instance;
        }
    }

    public static Singleton7_2 getInstance(){
        return Holder.INSTANCE.getINstance();
    }
}