设计模式系列教程—Singleton Pattern（单例模式）

前言：单例模式是为了解决在程序中只能有一个的问题，例如在我们的程序中经常用到的线程池、缓存、对话框和注册表等对象，都只需要实例化一个，后面其他线程要用的时候都直接拿过来用即可。

案例分析：

REQ1：Vander接到这么个需求，就是要创建一个糖果工厂来制造糖果，在糖果工厂放入蔗糖原料前必须保证熔炉是空的，接着在熔炉中煮沸并加入其它原料，此时必须保证熔炉不是空的并且是没有煮过的，最后将熔炉中的糖浆倒出到下一个机器进行冷却再加工。设计如下：

image.png

分析：首先这需要保证，程序中有且仅有一个CandyBoiler，不然就可能会出现在没有fill之前就直接boil了的情况，首先要保证能够实例化不能放在类外面，所以可以通过将构造方法私有化，于是代码就是这么写的：

public class CandyBoiler1 {

    private boolean empty;
    
    private boolean boiled;
    
    private static CandyBoiler1 candyBoiler1;
    
    private CandyBoiler1() {
        System.out.println("_______________CandyBoiler Constructor____________");
        empty = true;
        boiled = false;
    }

    public static CandyBoiler1 getInstance() {
        if(candyBoiler1 == null) {
            candyBoiler1 = new CandyBoiler1(); 
        }
        return candyBoiler1;
    }
    
    public void fill() {
        if(isEmpty()) {
            System.out.println("___________fill material___________");
            empty = false;
            boiled = false;
        }
    }
    
    public void boil() {
        if((!isBoiled()) && (!isEmpty())) {
            System.out.println("___________boil material___________");
            empty = false;
            boiled = true;
        }
    }
    
    public void drain() {
        if((isBoiled()) && (!isEmpty())) {
            System.out.println("___________drain material___________");
            //将糖浆倒出后恢复原状态
            empty = true;
            boiled = false;
        }
    }
    
    public void makeCandy() {
        fill();
        boil();
        drain();
    }
    
    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
    
}

说明：这么一来，在实现的时候发现，无法应对多线程的情况：

public class Main {

    public static void main(String[] args) {
        CandyProducer1 pro1 = new CandyProducer1();
        Thread thread1 = new Thread(pro1);
        CandyProducer2 pro2 = new CandyProducer2();
        Thread thread2 = new Thread(pro2);
        CandyProducer3 pro3 = new CandyProducer3();
        Thread thread3 = new Thread(pro3);
        
        thread1.start();
        thread2.start();
        thread3.start();

    }

}

结果：发现CandyBoiler被创建了3次，为什么呢？

image.png

说明：这是由于线程1刚开始肯定需要创建新的CandyBoiler，接着进入构造方法中，打印CandyBoiler Constructor，打印较为费时，此时线程2来了，线程2发现此时candyBoiler1为null，因为实际上此时线程1还在处理print语句，还没有完成创建呢，这样就导致了创建了两个CandyBoiler。

image.png

解决方法1：synchronized

Vander 又开始改进设计了，Vander想起以前学过synchronized关键字，这样还不简单，每次只允许一个线程访问getInstance方法，在getInstance方法加入synchronized关键字即可。
重新修改getInstance方法：

    public static synchronized CandyBoiler2 getInstance() {
        if(candyBoiler2 == null) {
            candyBoiler2 = new CandyBoiler2(); 
        }
        return candyBoiler2;
}

REQ2：接着Vander进行测试，果然只创建了一个CandyBoiler对象，正当Vander沾沾自喜，以为完美解决了问题的时候，Panda出现了，Panda说你这么写你就不怕影响性能吗？每次线程要来获取CandyBoiler的时候，都需要等其它线程拿完了才能拿，这样根本无法应对高并发量的需求。Vander一听，难道还有别的解决方法吗？

解决方法2：使用“急切”创建实例**

Panda大师说这个问题其实还有两种解决方法，其实new CandyBoiler()，这句话只会运行一次，其实也可以在刚开始加载CandyBoiler的时候，直接就把这个锅炉对象new出来，后面全是拿来用就行了。

public class CandyBoiler3 {

    private boolean empty;
    
    private boolean boiled;
    
    private static CandyBoiler3 candyBoiler3 = new CandyBoiler3();
    
    private CandyBoiler3() {
        System.out.println("_______________CandyBoiler Constructor____________");
        empty = true;
        boiled = false;
    }

    public static CandyBoiler3 getInstance() {
        return candyBoiler3;
    }
    … … … …
    … … … …
}

说明：坏处：提前将实例创建好，而不是等到要用的时候才创建，如果应用程序总是创建并使用单例，或者在创建和运行时方面的负担不太繁重，可以在初始化这个类的时候就创建此单件。

解决方法3：**使用“双重检查加锁”，在getInstance()中减少使用同步。

利用双重检查加锁，首先检查是否实例已经创建，如果尚未创建才进行同步，这样依赖就只有第一次会同步。

public class CandyBoiler4 {

    private boolean empty;
    
    private boolean boiled;
    
    private volatile static CandyBoiler4 candyBoiler4;
    
private CandyBoiler4() {
        System.out.println("_______________new CandyBoiler()____________");
        empty = true;
        boiled = false;
    }

    public static CandyBoiler4 getInstance() {
        if(candyBoiler4 == null) {
            synchronized (CandyBoiler4.class) {
                if(candyBoiler4 == null) {
                    candyBoiler4 = new CandyBoiler4();  
                }
            }
        }
        return candyBoiler4;
    }
    … … … …
    … … … …

}

最后的最后，我们又来总结我们现在现有的设计模式武器。

面向对象基础

抽象、封装、多态、继承

六大设计原则

设计原则一：封装变化
设计原则二：针对接口编程，不针对实现编程。
设计原则三：多用组合，少用继承。
设计原则四：为交互对象之间的松耦合设计而努力
设计原则五：对扩展开放，对修改关闭
设计原则六：依赖抽象，不要依赖于具体的类

模式

单例模式：确保一个类只有一个实例，并提供全局访问点。