2021-05-18

设计模式--单例模式（singleton）

单例模式是什么？

单例模式即是指一个类只能有一个实例。

单例模式的特点是什么？

单例类只有一个实例对象；该单例对象必须由单例类自行创建；单例类对外提供一个访问该单例的全局访问点。

单例模式优缺点

优点：1.单例模式可以保证内存里只有一个实例，减少了内存的开销。2.可以避免对资源的多重占用。3.单例模式设置全局访问点，可以优化和共享资源的访问。

缺点：1.单例模式一般没有接口，扩展困难。扩展，需修改原来的代码，违背开闭原则。2.在并发测试中，单例模式不利于代码调试。

日常用途有哪些？

主要生成用于不可修改的实例对象，供全局访问。比如数据库中的连接池。

单例有几种实现方式？

根据加载方式的差异，可以分为懒汉式和饿汉式。饿汉式在类加载时已经生成实例对象，懒汉式在需要时再生成实例对象。

因此，饿汉式是线程安全的，懒汉式在多线程情况下会不安全。

有哪些常见的单例写法？

写法核心：1.私有化构造方法 2.提供获取实例的方法

其实照这个思路写，写法不止这些。看到过一种用threadLocal写的，我没太懂，就不贴了，搞懂再补上。

1.饿汉式--普通

在类加载时直接生成实例对象。安全但可能会产生不必要的实例对象，浪费资源。其实如果确定要用到单例，这个差不多就够了

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * Class.forName("")
 * 
 */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

}

2.饿汉式--静态代码块

和第一种没啥区别

/**
 * 跟普通的是一个意思
 */
public class Mgr02 {
    private static final Mgr02 INSTANCE;
    static {
        INSTANCE = new Mgr02();
    }

    private Mgr02() {};

    public static Mgr02 getInstance() {
        return INSTANCE;
    }


}

3.懒汉式--普通

需要时才生成实例，避免资源浪费，但是多线程环境下不安全，写这个纯粹为了是引出后面的

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

}

4.懒汉式--加锁

解决了线程不安全的问题，但是加锁导致性能降低

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

    public static synchronized Mgr04 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }

}

5.懒汉式--DCL(double-checked locking)

这种写法看似没问题，实则会出错。我看某著名网课老师教单例写法就用的这个，后来还是学员提醒要加volatile他才意识到问题，可见错误率很高。

因此这个也是高频面试题，具体的我后面写文章再总结一下。

/**
 * DCL模式-- double-checked locking
 * 将锁的颗粒度变小，提高效率
 * 但可能出现指令重排序出现的线程安全问题
 * 概率极小
 */
public class MgrDCL {
    private static MgrDCL INSTANCE;

    private MgrDCL() {
    }

    public static MgrDCL getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (MgrDCL.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new MgrDCL();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

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

6.懒汉式--DCL+volatile

volatile修饰之后保持线程之间变量可见性，并禁止指令重排序，解决DCL的线程安全问题

/**
 * DCL模式-- double-checked locking
 * 将锁的颗粒度变小，提高效率
 * 但无法解决线程安全问题
 * 加上volatile即可解决
 * 可见性&禁止指令重排序
 */
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; 

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

}

7.懒汉式--静态内部类

既能保证安全又能懒加载，推荐使用

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class Mgr07 {

    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }


}

8.枚举类

Effective Java 强烈推荐，个人不喜欢用

/**
 * 不仅可以解决线程同步，还可以防止反序列化。
 * 因为枚举反编译后是抽象类
 * effective java推荐使用这一种
 */
public enum Mgr08 {
    INSTANCE;

    public void m() {
    }


}