设计模式-单例模式的5种方式

设计模式-单例模式

1，什么是单例模式

单例模式是23种设计模式中最简单的一种设计模式

作用：可以保证JVM中同一个对象永远只有一个

单例模式要领:

• 1，构造方法私有化
• 2，对外提供一个公开的静态的返回当前类型对象的方法
• 3，提供一个当前类型的私有静态变量

2，单例模式创建方式：

1.饿汉式:

• 类初始化时,会立即加载该对象，线程天生安全,调用效率高。

2.懒汉式:

• 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。

3.静态内部方式:（推荐使用）

• 结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。

4.枚举单例:

• 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。

5.双重检测锁方式

• (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)

3，懒汉式单例模式

package com.example.javabasis.design_patterns.singleton;

/**
 * @description: 单例模式-懒汉式
 * @create: 2019-07-19 21:20
 * @author:
 **/
public class Singleton_01 {

    private static Singleton_01 singleton;

    private Singleton_01() {
    }

    /**
     * 使用方法同步代码块，双重判空检验。
     * 保证返回一个实例，同一时刻只运行一个线程访问getInstans 方法
     *
     * @return
     */
    public static Singleton_01 getInstans2() {
        if (singleton == null) {
            synchronized (Singleton_01.class) {
                if (singleton == null) {
                    singleton = new Singleton_01();
                }
            }
        }
        return singleton;
    }

}

4，饿汉式单例模式

package com.example.javabasis.design_patterns.singleton;

/**
 * @description: 饿汉式单例模式，不存在线程安全问题。
 * @create: 2019-07-19 21:36
 * @author:
 **/
public class Singleton_02 {

    private static Singleton_02 singleton = new Singleton_02();

    private Singleton_02() {}

    public static Singleton_02 getInstans(){
        return singleton;
    }

}

5，使用枚举实现单例模式

package com.example.javabasis.design_patterns.create_type.singleton;

/**
 * @description: 使用枚举类实现单例模式
 * @create: 2019-07-21 15:36
 * @author:
 */
public class EnumSingleton {

    private EnumSingleton() {
    }

    public static EnumSingleton getInstance() {
        return InnerEnum.INSTANCE.getInstance();
    }

    static enum InnerEnum {
        INSTANCE;
        private EnumSingleton enumSingleton;

        private InnerEnum() {
            this.enumSingleton = new EnumSingleton();
        }

        private EnumSingleton getInstance(){
            return this.enumSingleton;
        }
    }

}

6，使用静态内部类，实现单例模式（推荐使用）

package com.example.javabasis.design_patterns.create_type.singleton;

/**
 * @description:
 * @create: 2019-07-21 16:11
 * @author:
 */
public class Singleton_03 {

    private Singleton_03() {
        System.out.println("初始化..");
    }

    private static class SingletonClassInstance {
        private static final Singleton_03 SINGLETON_03 = new Singleton_03();
    }

    // 方法没有使用同步关键字
    public static Singleton_03 getInstance() {
        System.out.println("getInstance");
        return SingletonClassInstance.SINGLETON_03;
    }

    public static void main(String[] args) {
        Singleton_03 s1 = Singleton_03.getInstance();
        Singleton_03 s2 = Singleton_03.getInstance();
        Singleton_03 s3 = Singleton_03.getInstance();
        System.out.println(s1 == s2 && s2 == s3);
    }

}

7，测试类

package com.example.javabasis.design_patterns.create_type.singleton;

public class SingletonTest {

    public static void main(String[] args) {
        // 懒汉单例模式
        Singleton_01 instans1 = Singleton_01.getInstans();
        Singleton_01 instans2 = Singleton_01.getInstans();
        System.out.println(instans1 == instans2);

        // 饿汉单例模式
        Singleton_02 singleton01 = Singleton_02.getInstans();
        Singleton_02 singleton02 = Singleton_02.getInstans();
        System.out.println(singleton01 == singleton02);

        // 枚举单例模式
        EnumSingleton enumSingleton = EnumSingleton.getInstance();
        EnumSingleton enumSingleton2 = EnumSingleton.getInstance();
        System.out.println(enumSingleton == enumSingleton2);
    }

}