单例模式的7种写法

---

1. 懒汉模式，单例实例在第一次使用时进行创建，非线程安全

/**
 * @program: Singleton
 * @description: 懒汉模式，单例实例在第一次使用时进行创建，非线程安全
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:15
 **/
public class SingletonDemo1 {
    //私有构造方法
    private SingletonDemo1() {
    }

    //单例对象
    private static SingletonDemo1 instance = null;

    //静态工厂方法
    public static SingletonDemo1 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo1();
        }
        return instance;
    }
}

2. 饿汉模式，单例实例在类装载时进行创建，线程安全

/**
 * @program: Singleton
 * @description: 饿汉模式，单例实例在类装载时进行创建，线程安全
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:21
 **/
public class SingletonDemo2 {

    //私有构造方法
    private SingletonDemo2() {
    }

    //单例对象
    private static SingletonDemo2 instance = new SingletonDemo2();

    //静态的工厂方法
    public static SingletonDemo2 getInstance() {
        return instance;
    }
}

3. 懒汉模式，单例实例在第一次使用时进行创建，线程安全，不推荐使用

/**
 * @program: Singleton
 * @description: 懒汉模式，单例实例在第一次使用时进行创建，线程安全，不推荐使用
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:29
 **/
public class SingletonDemo3 {
    //私有构造方法
    private SingletonDemo3() {
    }

    //单例对象
    private static SingletonDemo3 instance = null;

    //静态工厂方法
    public static synchronized SingletonDemo3 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo3();
        }
        return instance;
    }
}

4. 懒汉模式，双重同步锁单例模式，单例实例在第一次使用时创建，非线程安全

/**
 * @program: Singleton
 * @description: 懒汉模式，双重同步锁单例模式，单例实例在第一次使用时创建，非线程安全
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:38
 **/
public class SingletonDemo4 {
    //私有构造方法
    private SingletonDemo4() {
    }

    //单例对象
    private static SingletonDemo4 instance = null;

    //静态工厂方法
    public static SingletonDemo4 getInstance() {
        //双重检测机制
        if (instance == null) {
            //同步锁
            synchronized (SingletonDemo4.class) {
                if (instance == null) {
                    instance = new SingletonDemo4();
                }
            }
        }
        return instance;
    }
}

5. 懒汉模式，双重同步锁单例模式，单例实例在第一次使用时创建，线程安全

/**
 * @program: Singleton
 * @description: 懒汉模式，双重同步锁单例模式，单例实例在第一次使用时创建，线程安全
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:45
 **/
public class SingletonDemo5 {

    //私有构造方法
    private SingletonDemo5() {
    }

    //单例对象 volatile + 双重检测机制 -> 禁止指令重排
    private volatile static SingletonDemo5 instance = null;

    //静态工厂方法
    public static SingletonDemo5 getInstance() {
        //双重检测机制
        if (instance == null) {
            //同步锁
            synchronized (SingletonDemo5.class) {
                if (instance == null) {
                    instance = new SingletonDemo5();
                }
            }
        }
        return instance;
    }
}

6. 饿汉模式，单例实例在类装载时进行创建，线程安全

/**
 * @program: my-blog
 * @description: 饿汉模式，单例实例在类装载时进行创建，线程安全
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:56
 **/
public class SingletonDemo6 {
    //私有构造方法
    private SingletonDemo6() {
    }

    //单例对象
    private static SingletonDemo6 instance = null;

    static {
        instance = new SingletonDemo6();
    }

    //静态工厂方法
    public static SingletonDemo6 getInstance() {
        return instance;
    }
}

7. 枚举模式，线程安全，推荐使用

/**
 * @program: Singleton
 * @description: 枚举模式，线程安全，推荐使用
 * @author: Mr.superbeyone
 * @create: 2018-09-30 09:59
 **/
public class SingletonDemo7 {
    //私有构造方法
    private SingletonDemo7() {
    }

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

    private enum Singleton {
        INSTANCE;
        private SingletonDemo7 singleton;

        //JVM保证这个方法绝对只调用一次
        Singleton() {
            singleton = new SingletonDemo7();
        }

        private SingletonDemo7 getInstance() {
            return singleton;
        }
    }
}