单例模式（懒汉式和饿汉式）

单例模式可分为饿汉式和懒汉式
饿汉式单例模式：

直接创建实例对象，不管你是否需要创建这个对象

懒汉式单例模式：

延迟创建对象

创建思路

• （1）构造器私有化
• （2）自行创建，并用静态变量保存
• （3）向外部提供这个示例
• （4）强调这是一个单例，用final修饰

第一种、饿汉式

/*
 * @ClassName Singleton
 * @Author Final
 * 单例设计模式
 * @Project DataStructures
 *
public class Singleton {

		//创建静态变量、用final修饰
        public static  final Singleton INSTANCE = new Singleton();
		//创建私有化构造器
        private Singleton(){ }
}

第二种、饿汉式：枚举类型

/**
 * 饿汉式
 * 枚举类型：该类想对象是有限的几个
 *      限定一个
 * @ClassName Singleton1
 * @Author Final
 * @Project DataStructures
 */
public enum  Singleton1 {
    INSTANCE;
}

第三种、静态代码块创建（我的代码块有问题，但是思路没错）

/**
 * 饿汉式
 * @ClassName Singleton2
 * @Author Final
 * @Project DataStructures
 */
public class Singleton2 {

    public static Singleton2 INSTANCE = null;

    private String key;

    static {

        try {

            INSTANCE=new Singleton2();
        } catch (Exception e) {
            e.printStackTrace();
        }


    }


    private Singleton2(){

    }
}

静态代码块在类加载时调用,并且只调用一次，依据这种原理去创建对象

第四种、懒汉式：线程安全

/**
 * 懒汉式：
 *      延迟创建对象
 *      （1）构造器私有化
 *      （2）提供给一个静态变量保存这个唯一的实例
 *      提供一个静态方法，获取这个实例
 * @ClassName Singleton4
 * @Author Final
 * @Project DataStructures
 */
public class Singleton3 {
    private static Singleton3 instance;
    private Singleton3(){

    }
    public static Singleton3 getInstance(){

        if (instance==null){
            synchronized (Singleton3.class){
                if (instance==null){
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance=new Singleton3();
            }
        }
            return instance;
    }
}

采用synchronized线程安全控制，这样在创建的时候就只有一个对象且相同。

第五种、懒汉式：静态方法调用

/**
 * 懒汉式：
 *      延迟创建对象
 *      （1）构造器私有化
 *      （2）提供给一个静态变量保存这个唯一的实例
 * 		（3）通过一个静态方法去创建实例
 *      提供一个静态方法，获取这个实例
 * @ClassName Singleton4
 * @Author Final
 * @Project DataStructures
 */
public class Singleton4 {
    private static Singleton4 instance;
    private Singleton4 (){

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

第六种、懒汉式：内部类加载创建

/**
 *
 * 在内部类被加载和初始化时，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，踏实单独去加载和初始化的。
 * @ClassName Singleton5
 * @Author Final
 * @Project DataStructures
 */
public class Singleton5 {

    private Singleton5(){

    }
    private static class Inner{
        private static final Singleton5 INSTANCE=new Singleton5();
    }

    public static Singleton5 getInstance(){
        return Inner.INSTANCE;
    }
}

• 在内部类被加载和初始化时，才创建INSTANCE实例对象
• 静态内部类不会自动随着外部类的加载和初始化而初始化，踏实单独去加载和初始化的。