23种设计模式-单例模式

1. 我是皇帝我独苗

原书通过皇帝这一角色来解释何为单例模式，可以说是很形象。自从秦始皇确立了皇帝这个位置后，同一时期基本就只有一个人坐这个位置，这种情况下臣民也好处理，大家谈论皇帝都知道指的是谁，而不用加上其他特定的称呼。这一场景反应到设计领域就是要求一个类只能生成一个对象，所有对象对他的依赖都是相同的，因为只有一个对象，大家对他的行为都非常了解，建立健壮稳固的关系，一个类只能产生一个对象该怎么实现呢？对象的产生一般是通过new关键字来完成的（当然也有其他的方式，比如复制、反射等，甚至序列化也会导致单例被破坏，这几种方式都可以生成多个实例），这个怎么控制呢？使用new关键字创建对象时，都会根据输入的参数调用相应的构造函数，如果我们把构造函数设置为private私有访问权限不就禁止了外部创建对象了吗？臣子叩拜唯一皇帝的类图7-1：

7-1

代码如下：

public class Emperor {
    private static final Emperor emperor = new Emperor();

    private Emperor(){}

    public static Emperor getInstance(){
        return emperor;
    }

    public void say(){
        System.out.println("我是皇帝某某某。。。");
    }
}
public class Minister {
    public static void main(String[] args) {
        for(int days = 0;days<3;days++){
            Emperor emperor = Emperor.getInstance();
            emperor.say();
        }
    }
}

这就最简单的饿汉式单例模式，这种写法比较简单，而且也是线程安全的，但是一般我们都是将比较重的类做单例，如果一直没用过这个就会造成内存的浪费。

2. 单例模式的定义

单例模式（Singleton Pattern）是一个比较简单的模式，其定义如下：
Ensure a class has only one instance,and provide a global point of access to it.（确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）
单例模式的通用类图如图7-2：

7-2

Singleton类称为单例类，通过private构造函数确保一个应用中只产生一个实例，并且是自行实例化的（在Singleton中自己使用new Singleton()）。

3. 单例模式的应用

3.1 单例模式的优点

• 由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建销毁时，而且创建或销毁的性能又无话优化，单例模式的优势就非常明显。
• 由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决（按照jvm的垃圾回收机制，单例的实例是由类的内部自己持有，那么单例的实例是不会被回收的，而且单例类也不会被回收）
• 单例模式可以避免对资源的多重占用，例如写一个文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作（这个有点不太明白）
• 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理

3.2 单例模式的缺点

• 单例模式一般没有接口，扩展困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能有接口呢？因为接口对单例模式没有任何意义，他要求"自行实例化"，并且提供单一实例、接口或抽象类是不可能被实例化的。当然在特殊情况下，单例模式可以实现接口、被继承等，需要在系统开发中根据环境判断。（这个单例实现接口和被继承的情况还没有遇见过，具体是什么样的还得看看）
• 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关系它是否是单例的，是不是单例取决于环境，单例模式把"要单例"和业务逻辑融合在一个类中。

3.3 单例模式的使用场景
在一个系统中，要求一个类有且仅有一个对象，如果出现多个对象就会出现"不良反应"，可以采用单例模式，具体场景如下：

• 要求生成唯一序列号的场景；
• 在整个项目中需要一个共享访问点或共享数据，例如一个web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保线程安全的；
• 创建一个对象需要消耗的资源过多，如要访问IO和数据库资源；（确实，例如说数据库连接池这个类应该是单例的，确保全局的数据连接都是使用这个连接池中的连接，这样的设计才是比较合理的）
• 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（这个工具类中的方法一般用的是用static方法）

3.4 单例模式的注意事项
首先，在高并发的情况下，请注意单例模式的线程同步问题。单例模式有几种不同的实现方式 ，上面的例子不会出现产生多个实例的情况，但是如下代码会：

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

这个是懒汉式的单例，这个就是在需要用的时候才会去创建实例，但是这个有线程安全问题，在多线程的情况下可能会创建出多个实例来，这个就会有问题了。

为了解决线程安全问题在getInstance方法加上synchronized关键字，但是不建议，synchronized是比较影响性能的。还有反射、克隆和序列化可能会导致出现多个实例，这也是可能需要处理的问题。一下有几种单例的实现：

//加上synchronized 来处理线程安全问题
public class Singleton {
    private static Singleton singleton = null;

    private Singleton(){

    }
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}
//对上一种进行优化，虽然效率有所提高，但是线程安全的问题还是存在
public class Singleton {
    private static Singleton singleton = null;

    private Singleton(){

    }
    public static  Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}
//对上一种方式接着改进，多加一层验证，就不会出现上面的问题（推荐用）
public class Singleton {
    private static volatile Singleton singleton ;

    private Singleton(){

    }
    public static  Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class) {
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
//静态内部类方式，利用类的加载机制来完成这个单例（推荐）
public class Singleton {
    private Singleton(){

    }
    public static  Singleton getInstance(){
        return SingletonHolder.singleton;
    }
    private static class SingletonHolder{
       private static final Singleton singleton = new Singleton();
    }
}

以上几种方式都是从最基本的懒汉式和饿汉式优化而来。可以看出虽然基本的思路很简单就是将构造函数私有化，但是其中涉及到的问题有很多，这就是程序的魅力，还有怎么防止反射和克隆（克隆的问题，不实现Cloneable接口就好了）的问题。
反射的问题，代码如下：

public class Client {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        Class clz = Singleton.class;
        Constructor con = clz.getDeclaredConstructor(null);
        con.setAccessible(true);
        Singleton singleton3 = (Singleton) con.newInstance(null);
        System.out.println(singleton1);
        System.out.println(singleton2);
        System.out.println(singleton3);
    }
}
运行结果：
Singlecase.Singleton@47fd17e3
Singlecase.Singleton@47fd17e3
Singlecase.Singleton@7cdbc5d3

反射是通过他的Class对象来调用构造器创建出新的对象，我们只需要在构造器中手动抛出异常，导致程序停止就可以达到目的了，看下面代码：

public class Singleton{
    private Singleton(){
        if(SingletonHolder.singleton != null){
            throw new RuntimeException();
        }
    }
    public static  Singleton getInstance(){
        return SingletonHolder.singleton;
    }
    private static class SingletonHolder{
       private static final Singleton singleton = new Singleton();
    }
}

这种方式通过反射去创建就会抛出运行时异常了，我是这样理解的不知道对不对，
当我们使用反射的方式去调用构造函数时，先进入到判断中，会去调用SingletonHolder.singleton，这个会触发内部类的加载，然后通过new创建出了一个实例（这个时候new的时候应该也会判断，但是实例还没有创建，就可以创建成功），再去判断不等于空，就会抛出异常了；
（这些方式有所了解就好了，这是给我们提供了解决问题思路从而更理解单例这个东西，一般实际开发中我们也不会自己去写这样的代码来破坏自己创建的单例，这个可能是我见识少了，我没见过这种搞法，哈哈）

在看一下序列化破坏单例的问题，代码如下：

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:/test.txt"));
        oos.writeObject(singleton1);
        oos.flush();
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:/test.txt"));
        Singleton singleton3 = (Singleton) ois.readObject();
        System.out.println(singleton1);
        System.out.println(singleton2);
        System.out.println(singleton3);
    }
}

运行结果：
Singlecase.Singleton@3f0ee7cb
Singlecase.Singleton@3f0ee7cb
Singlecase.Singleton@5056dfcb

看序列化问题的解决方法：

public class Singleton implements Serializable {
    private Singleton(){
        if(SingletonHolder.singleton != null){
            throw new RuntimeException();
        }
    }
    public static  Singleton getInstance(){
        return SingletonHolder.singleton;
    }
    private static class SingletonHolder{
       private static final Singleton singleton = new Singleton();
    }

    private Object readResolve() throws ObjectStreamException {
        return getInstance();
    }
}

这个方法是基于回调的，反序列化时，如果定义了readResolve()则直接返回此方法指定的对象，而不需要在创建新的对象。

4. 单例模式的扩展

如果一个类可以产生多个对象，对象的数量不受限制，则是非常容易实现的，直接使用new关键词就可以了，如果只需要一个对象，使用上面的单例就好了，但是如果要求一个类只能产生两三个对象呢？改怎么实现？我们还是以皇帝的例子来展示，类图7-3：

7-3

代码如下：

public class Emperor {
    //先定义产生实例的数量
    private static int maxNumOfEmperor = 2;
    private static ArrayList<Emperor> list = new ArrayList<>();
    static{
        for(int i=0;i<maxNumOfEmperor;i++){
            list.add(new Emperor());
        }
    }

    private Emperor(){}

    public static Emperor getInstance(){
        return list.get(new Random().nextInt(maxNumOfEmperor));
    }
}

这种需要产生固定数量对象的模式就叫做多例模式，这个可以修正单例的性能问题（这个我还需要多实践）

5. 最佳实践

这个模式应用非常广泛，如在Spring中，每个Bean的默认就是单例的，这样做的优点是Spring容器可以管理这些Bean的声明周期，决定什么时候创建，什么时候销毁，销毁时如何处理等。如果非单例模式，则Bean的初始化后的管理交由J2EE容器，spring容器不在跟踪管理Bean的生命周期。

内容来自《设计模式之禅》