一.饿汉模式

/**
 * 饿汉式，
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全，
 * 简单使用
 * 缺点：无论是否使用，类装载时就实例化
 * Class.forName("")
 * */

public class SingleDesign {
    public final static SingleDesign instance = new SingleDesign();
    private SingleDesign(){}
    public static SingleDesign getSingleInstance(){
        return instance;
    }


    public static void main(String[] args){
    }
}

二.懒汉模式

/**
 * 懒汉式
 * 线程不安全
 * 可以通过加synchronized来保证线程安全，不过会导致性能下降
 * */
public class SingleDesign2 {
    private static volatile SingleDesign2 instance = null;
    private SingleDesign2(){}

    public static synchronized SingleDesign2 getSingleInstance(){
        if (instance == null){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new SingleDesign2();
        }

        return instance;
    }

    public static void main(String[] args){
        //System.out.println(SingleDesign2.getSingleInstance() == SingleDesign2.getSingleInstance());
        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingleDesign2.getSingleInstance().hashCode());
            }).start();
        }
    }
}

三.双重条件下的懒汉模式

/**
 * 懒汉式地进一步优化
 * 双重检查
 * 线程安全
**/
public class SingleDesign3 {
    private static volatile SingleDesign3 instance = null;
    private SingleDesign3(){}

    public static SingleDesign3 getSingleInstance(){
        if (instance == null){
            //双重检查
            synchronized (SingleDesign3.class){
                if (instance == null){
                    instance = new SingleDesign3();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args){
        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingleDesign3.getSingleInstance().hashCode());
            }).start();
        }
    }
}

四.内部类实现方式

/**
 * 使用内部类的方式实现，线程安全，更加完美的方式
 *
 * */
public class SingleDesign4 {
    private SingleDesign4(){}

    public static SingleDesign4 getSingleInstance(){
        return InnerSingleDesign4.instance;
    }

    //内部类
    private static class InnerSingleDesign4{
        private static final SingleDesign4 instance = new SingleDesign4();
    }

    public static void main(String[] args){

        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingleDesign4.getSingleInstance().hashCode());
            }).start();
        }
    }
}

五.枚举实现方式

/**
 * 不仅可以解决线程同步，还可以防止反序列化（枚举没有构造方法）,最完美的方式
 *
 *
 * */
public enum SingleDesign5 {
    INSTANCE;

    public static void main(String[] args){
        for (int i=0;i<100;i++){
            new Thread(()->{
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(SingleDesign5.INSTANCE.hashCode());
            }).start();
        }
    }
}