前言：单例模式是为了解决在程序中只能有一个的问题，例如在我们的程序中经常用到的线程池、缓存、对话框和注册表等对象，都只需要实例化一个，后面其他线程要用的时候都直接拿过来用即可。
案例分析：
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;
}
… … … …
… … … …
}
最后的最后，我们又来总结我们现在现有的设计模式武器。
面向对象基础
抽象、封装、多态、继承
六大设计原则
设计原则一：封装变化
设计原则二：针对接口编程，不针对实现编程。
设计原则三：多用组合，少用继承。
设计原则四：为交互对象之间的松耦合设计而努力
设计原则五：对扩展开放，对修改关闭
设计原则六：依赖抽象，不要依赖于具体的类
模式
单例模式：确保一个类只有一个实例，并提供全局访问点。
网友评论