文集地址

一句话总结单例模式

• 一个JVM中只有一个对象的实例，防止反复创建对象

前言

• 单利模式隶属于创建型设置模式,其目的是为了防止实例重复创建，通过单例模式创建的类在当前进程中只有一个实例,单例模式是一种常用的软件设计模式，七种写法，分别适应了不同场景，下面一一举例。

懒汉式

• 优点：只有在调用 getSimpleInterest() 时才会创建实例，节省资源
• 缺点：非线程安全，不能再多线程下使用，因在调用时才初始化实例，所有第一次初始时间略长

/**
 * 懒汉式（非线程安全）
 *
 * @author ext.liuyan10
 * @date 2021/2/5 9:19
 */
public class SimpleInterest01 {
    private static SimpleInterest01 simpleInterest;

    public SimpleInterest01() {
    }
    //获取实例
    public static SimpleInterest01 getSimpleInterest() {
        if (null == simpleInterest){
            simpleInterest = new SimpleInterest01();
        }
        return simpleInterest;
    }
}

懒汉变种

• 优点：只有在调用 getSimpleInterest() 时才会创建实例，节省资源，线程安全
• 缺点：因为加了 synchronized 锁机制，初始化会变得更重，时间更长，且效率低

/**
 * 懒汉变种(线程安全)
 *
 * @author ext.liuyan10
 * @date 2021/2/5 9:28
 */
public class SimpleInterest02 {
    private static SimpleInterest02 simpleInterest;

    public SimpleInterest02() {
    }

    public static synchronized SimpleInterest02 getSimpleInterest() {
        if (null == simpleInterest){
            simpleInterest = new SimpleInterest02();
        }
        return simpleInterest;
    }
}

饿汉

• 优点：通过类加载器（ClassLoader）创建实例，有效避免了线程安全问题
• 缺点：项目启动的时间会变得更长

/**
 * 饿汉
 * @author ext.liuyan10
 * @date 2021/2/5 9:39
 */
public class SimpleInterest03 {
    private static SimpleInterest03 simpleInterest = new SimpleInterest03();

    public SimpleInterest03() {
    }

    public static SimpleInterest03 getSimpleInterest() {
        return simpleInterest;
    }
}

恶汉变种

• 与恶汉只是写法不一样，优缺点也一样

/**
 * 恶汉变种
 *
 * @author ext.liuyan10
 * @date 2021/2/5 11:20
 */
public class SimpleInterest04 {
    public static SimpleInterest04 simpleInterest = null;
    static {
        simpleInterest = new SimpleInterest04();
    }

    public SimpleInterest04() {
    }

    public static SimpleInterest04 getSimpleInterest() {
        return simpleInterest;
    }
}

双重检验锁

• 优点：只有在调用 getSimpleInterest() 时才会创建实例，节省资源，线程安全
• 缺点：因为 synchronized 锁机制，使得效率低，代码臃肿
• 总结：初始化个类写一堆，看着就烦，没见人写过

/**
 * 双重检验锁
 *
 * @author ext.liuyan10
 * @date 2021/2/5 11:26
 */
public class SimpleInterest05 {
    private volatile static SimpleInterest05 simpleInterest;

    public SimpleInterest05() {
    }

    public static SimpleInterest05 getSimpleInterest() {
        if (null == simpleInterest){
            synchronized (SimpleInterest05.class){
                if (null == simpleInterest){
                    simpleInterest = new SimpleInterest05();
                }
            }
        }
        return simpleInterest;
    }
}

静态内部类

• 优点：通过类加载器（ClassLoader）创建实例,线程安全，但只有在调用getInterest() 时 内部类才会被调用，才会创建实例
• 缺点：因在调用时才初始化实例，所有第一次初始时间略长

/**
 * 静态内部类
 *
 * @author ext.liuyan10
 * @date 2021/2/5 11:49
 */
public class SimpleInterest06 {
    private static class SimpleInterest {
        private static final SimpleInterest06 simpleInterest = new SimpleInterest06();
    }

    public SimpleInterest06() {
    }

    public static final SimpleInterest06 getInterest() {
        return SimpleInterest.simpleInterest;
    }
}

枚举

• 优点：安全系数比较高，能有效防止Java反射
• 缺点：写法比较奇特，很少有人写

/**
 * 枚举
 *
 * @author ext.liuyan10
 * @date 2021/2/5 11:53
 */
public enum SimpleInterest07 {
    INTEREST;

    public void getInterest() {

    }
}