设计模式-单例模式

单例模式

概念

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

UML类图

UML类图说明

1）getInstance()是一个静态方法，它是一个全局访问点，我们可以通过Singleton.getInstance()来访问它，

这和访问全局变量一样简单，只是多了一个优点：单例模式可以延迟实例化

2）类变量uniqueInstance用来指向唯一的类实例

单例模式的实现

分析：

　　依靠程序之间的约定或利用全局变量

　　比如利用Java的静态变量

　　　　　　　　V

　　单例模式经过了实践的考验，可确保只有一个实例被创建，

　　也给了我们一个全局访问点，优于程序员之间的约定和全局变量，

　　并且没有全局变量的缺点

　　　　　　　　V

　　全局变量的缺点：1）污染命名空间

　　　　　　　　　　2）在程序一开始就要创建对象，如果这个对象非常消耗资源，而程序的这次执行又没用到它，

　　　　　　　　　　就会造成浪费，单例模式可以在需要时创建。

单件模式的实现分析

　　一个类如果不是私有的，那么我们可以多次实例化它

　　　　　　　　　　　　V

　　如果把一个类（MyClass）的构造函数私有化，那么只有这个类（MyClass）内的代码才能

　　调用此构造器

　　　　　　　　　　　　V

　　必须有MyClass的实例才能调用MyClass构造器，没有其他类能够实例化MyClass，

　　这是个鸡生蛋蛋生鸡的问题

　　　　　　　　　　　　V

　　提供一个静态方法，通过类来调用，比如MyClass.getInstance()

　　　　　　　　　　　　V

　　你能够确保MyClass只能产生一个实例吗？答案是否定的

说明

1）我们把某个类设计成自己管理的一个单独实例，同时也避免了其他类再自行产生实例，

想要取得单例实例，通过单例类是唯一的途径

2）我们提供了对这个实例的全局访问点，当你需要实例时，向类查询，它会返回单个实例，

利用延迟实例化的方式创建单例对资源敏感的对象特别重要

单例模式基本实现

Singleton.java

package com.java.singleton;

public class Singleton {
    private static Singleton uniqueInstance = null;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

案例

ChocOHolic公司有工业强度巧克力锅炉控制器，锅炉负责把巧克力和牛奶融在一起，

然后送到下一个阶段，以制造巧克力棒，代码如下

ChocolateBoiler.java

package com.design.singleton;

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;
    
    //初始化时，锅炉室空的
    public ChocolateBoiler() {
        empty = true;
        boiled = false;
    }
    
    public boolean isEmpty() {
        return empty;
    }
    
    public boolean isBoiled() {
        return boiled;
    }
    
    //往锅炉填入原料时，锅炉必须是空的
    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
            //填入巧克力和牛奶的混合物
        }
    }
    
    //锅炉排出时，必须是满的并且是被煮过的
    public void drain() {
        if(!isEmpty() && isBoiled()) {
            //排出煮沸的巧克力和牛奶
            empty = true;
        }
    }
    
    //煮混合物时，锅炉必须是满的并且是没有被煮过的
    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            //将锅炉内的混合物煮沸
            boiled = true;
        }
    }
}

需求：公司担心同时有两个或两个以上的锅炉实例存在，可能会发生很糟糕的事，要求锅炉只能有一个实例

代码实现

ChocolateBoiler.java

package com.design.singleton;

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;
    
    //初始化时，锅炉室空的
//    public ChocolateBoiler() {
//        empty = true;
//        boiled = false;
//    }
    public static ChocolateBoiler chocolateBoiler = null;
    
    public static ChocolateBoiler getInstance() {
        if (chocolateBoiler == null) {
            chocolateBoiler = new ChocolateBoiler();
        }
        return chocolateBoiler;
    }
    
    private ChocolateBoiler() {
        empty = true;
        boiled = false;
    }
    
    
    public boolean isEmpty() {
        return empty;
    }
    
    public boolean isBoiled() {
        return boiled;
    }
    
    //往锅炉填入原料时，锅炉必须是空的
    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
            //填入巧克力和牛奶的混合物
        }
    }
    
    //锅炉排出时，必须是满的并且是被煮过的
    public void drain() {
        if(!isEmpty() && isBoiled()) {
            //排出煮沸的巧克力和牛奶
            empty = true;
        }
    }
    
    //煮混合物时，锅炉必须是满的并且是没有被煮过的
    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            //将锅炉内的混合物煮沸
            boiled = true;
        }
    }
}

问题：在用多线程改进代码时，发现fill()方法竟然允许在加热的过程中继续加入原料

分析

　　通过增加synchronized关键字到getInstance()方法中，

　　迫使每个线程在进入这个方法之前，要先等候别的线程离开这个方法

　　　　　　　　　　　　　　　V

　　但是同步会降低性能，并且只有第一次执行方法时才真正需要同步，

　　之后每次调用这个方法，同步都是一种累赘，同步一个方法可能造成

　　程序执行效率下降100

　　　　　　　　　　　　　　　V

　　如果你的程序可以接受getInstance()造成的额外负担，那就忘了这件事吧

　　　　　　　　　　　　　　　V

　　如果getInstance()方法调用比较繁琐，我们可以使用急切的创建实例，

　　而不用延迟实例化的做法

　　　　　　　　　　　　　　　V

　　依赖JVM在加载这个类时马上创建此类唯一的实例，JVM保证在任何线程访问唯一静态实变量之前，

　　先创建此实例

　　　　　　　　　　　　　　　V

　　利用双重检查加锁，首先检查实例是已经被创建，如果未被创建，才进行同步，

　　如果创建了，则不进行同步，这正是我们想要的：只有第一次才会同步。

synchronized实现

package com.design.singleton;

public class Singleton {
    public static Singleton instance = null;
    
    private Singleton() {}
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

急切创建实例实现

package com.design.singleton;

public class Singleton {
    public static Singleton instance = new Singleton();
    
    private Singleton() {}
    
    public static synchronized Singleton getInstance() {
        return instance;
    }
}

双重检查加锁实现

package com.design.singleton;

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

　　　　　　　　　　　　

应用场景

对于一些对象，我们只需要一个即可，比如，线程池、对话框、日志对象等，这类对象只能有一个实例，

如果制造多个实例，会产生许多问题，比如，程序的行为异常，资源使用过量或是结果不一致

比如，注册表设置的对象，你不希望这样的对象有多分拷贝吧，这样会把设置搞得一塌糊涂，

单例模式可以确保程序中使用的全局资源只有一份。