学习笔记【23种设计模式-第二节：Singleton单例模式】

设计模式类型

设计模式分为三种类型，共23种

• 创建型模式： 单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
• 结构型模式： 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
• 行为型模式： 模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式（责任链模式）。

Singleton(单例模式)

所谓类的单例模式，就是采取一定的方法保证在整个的软件系统中，对某个类只存放在一个对象实例，并且该类只提供一个取得其对象实例的方法。
（8种写法，这里写了六种，有两种只是简单的变种，没放代码。）

饿汉式

• 类加载到内存后，就实例一个单例，JVM保证线程安全。
• 简单实用！推荐使用！
• 唯一缺点：不管用到与否，类装载时都会完成实例化，可能造成内存浪费。
• 可用静态代码块new对象（一种）。

public class Test01 {
    private static final Test01 INSTANCE=new Test01();
    /*private static final Test01 INSTANCE;
    static {INSTANCE=new Test01();}*/
    private Test01(){}

    public static Test01 getInstance(){return INSTANCE;}

    public static void main(String[] args) {
        Test01 m1=Test01.getInstance();
        Test01 m2=Test01.getInstance();
        System.out.println(m1==m2);
    }
}

返回true，说明确实只创建了一个对象。

---

懒汉式

• lazy loading
• 某种情况下存在线程安全问题

public class Test02 {
    private static Test02 INSTANCE;
    private Test02(){}
    public static Test02 getInstance(){
        if (INSTANCE==null){

            INSTANCE=new Test02();
        }
        return INSTANCE;
    }

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

---

懒汉式加synchronized

• 效率太低，每一次都需要加锁

public class Test03 {
    private static volatile Test03 INSTANCE;
    private Test03(){}
    public static synchronized Test03 getInstance(){
        if (INSTANCE==null){INSTANCE=new Test03();}
        return INSTANCE;
    }

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

为了提高效率，有人说将synchronized加在if判断后，但这样也会有线程安全问题（一种）。

---

DCL单例（Double Check Lock双重锁判断机制）

线程安全，有双重判断，第一次判断，如果不为空，则不会再加锁，大幅提升效率，synchronized后的判断，是为了保证线程安全。

public class Test04 {
    private static volatile Test04 INSTANCE;
    private Test04(){}
    public static Test04 getInstance(){
        if (INSTANCE==null){
            synchronized (Test04.class){
                if (INSTANCE==null){
                    INSTANCE=new Test04();
                }
            }
        }
        return INSTANCE;
    }

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

面试题：DCL单例是否要加Volatile？
答：是要的，原因是synchronized虽然具备有序性，但只能保证synchronized中的结果不变，并不能禁止指令重排，volatile能禁止指令重排，其中涉及到内存屏障，会对volatile前后的读写操作不能进行重新排序。在DCL单例中，涉及到了对象的创建，对象创建在汇编实现上，大致会有三步，①创建内存空间，相当于半初始化；②执行构造函数，初始化（init）；③将INSTANCE引用指向分配的内存空间，相当于赋值。可能初始化与赋值发生指令重排，当第二个线程来了的时候，发现这里是有对象的了，就会用这个并未完成初始化的对象，导致读到错误的值。

---

静态内部类方式

• JVM保证单例
• 加载外部类时不会加载内部类
• 这样可以实现懒汉式

public class Test05 {

    private Test05(){}
    private static class Test05Holder{
        private static final Test05 INSTANCE=new Test05();
    }
    public static Test05 getInstance(){
        return Test05Holder.INSTANCE;
    }

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

---

枚举方式

• 不仅可以解决线程同步，还可以防止反序列化，没有构造方法。
• 这种方式是Effective Java作者Josh Bloch提倡的方式
• 推荐使用！

public enum Test06 {
    INSTANCE;

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

注意事项：

• 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
• 当实例化一个单例类的时候，必须记住使用象应的过去对象的方法，而不是使用new。
• 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据库源、session工厂等）。

下一篇：学习笔记【23种设计模式-第三节：工厂模式–简单工厂、工厂方法、抽象工厂】
上一篇：学习笔记【23种设计模式-第一节：设计模式的七大原则及初步了解UML】