Java设计模式-内功修炼-创建型设计模式-单例模式

单例模式

简述

单例模式(Singleton Pattern)：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

举例引出单例模式的重要作用：

• 现在请读者打开自己电脑的任务管理器，win10快捷键是esc+shift+ctrl，看到任务管理器界面出来以后，再次按上述快捷键，你会发现快捷键失效了，即任务管理器只能有一个。微软为什么规定只能有一个任务管理器呢？
• 因为简单高效：假设可以有多个任务管理器，那么我们要做的工作就是让这些任务管理器同步起来，这是一个麻烦事。假设一个任务管理器是一个线程，那么就有可能因为CPU调度等原因导致多个界面内容不统一，带给用户困扰。但如果仅允许一个任务管理器，既不会影响用户使用，还能降低系统复杂度。
• 上述所讲的任务管理器只能有一个就是单例模式的一个体现。
  

实现

单例模式分为饿汉式和懒汉式两种实现方式，为什么称为饿汉，为什么称为懒汉呢，见下文讲解

关于单例模式实现的一些要求：

1. 单例类不能在外部实例化，就是说我们不能new一个单例类，所以这需要我们将构造函数声明为私有的。
2. 在单例类的内部只生成一个实例，并且要提供静态getInstance()方法，此即用户访问的接口。

饿汉式实现

package Singleton;

public class Singleton1 {
    // 称为饿汉就是因为这行代码
    private static final Singleton1 instance = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return instance;
    }
}

为什么称为饿汉呢？

• 因为饿汉式的实例是在类加载时完成的，不是getInstance()时生成的，也就是提前生成的，很饥饿，等不及了，Singleton1类加载的时候就生成了，所以称为饿汉式。

个人理解

优点：

1. 其是线程安全的，因为一个对象中的静态变量只能有一个，所以无论怎么使用都不会出现多个实例
2. 代码简洁，容易理解，而且很方便，没有其他问题

缺点

1. 类加载时就会创建实例，即不管你什么时候用，类被加载该实例就被创建，如果不用的话，那就浪费系统资源了。
2. 会延长类加载时间。

懒汉式实现

1. 版本1：

package Singleton;

public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {

    }

    synchronized public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }

}

这里有一个关键字：synchronized，此为线程锁，为了解决多线程访问问题，即如果有多个线程同时执行到getInstance()方法，那么只能有一个线程先调用，其他线程被阻塞，等刚才的线程执行完毕后才能进入。

这种实现方式的缺点：没必要对整个方法添加synchronized关键字，因为我们只希望new语句只执行一次即可，所以衍生出版本2
2. 版本2

package Singleton;

public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {

    }

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

}

这个写法其实是错的，我们的确保证了instance = new Singleton2()在同一时刻只执行一次，但是如果有两个进程进入了if判断条件，那么就会有两个new被执行。
所以衍生出版本3
3. 版本3

package Singleton;

public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {

    }

    public static Singleton2 getInstance() {
        if (instance == null) {
        	//锁定代码块
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }

            }
        }
        return instance;
    }

}

锁定代码块之后确保同一时刻只有一个线程能进入，然后再判断一次，能改进第二版的缺陷，但是这样既引入了线程锁机制，又增加了一个if判断，显然会影响效率，所以寻求一种既正确又高效的做法，衍生出版本4
4. 版本4

package Singleton;

public class Singleton4 {
    private Singleton4() {

    }
	//关键所在
    private static class HolderClass {
        private final static Singleton4 instance = new Singleton4();
    }

    public static Singleton4 getInstance() {
        return HolderClass.instance;
    }
    
}

这里涉及到java运行机制的知识：即第一次调用getInstance()时会加载内部类HolderClass，因为其是static类型的，所以由java机制保证其唯一性以及线程安全性。这样的代码既简洁效率又高。

这种方法称为Initialization Demand Holder (IoDH)的技术。

不过这种方法比较依赖语言，这里利用的是java的运行机制，而其他面向对象语言未必会支持这种实现方式。

总结

单例模式的优点

1. 单例模式进行扩展后可以做到控制可变数目的实例，这样能够节省系统资源，还能解决单例对象共享过多有损性能的问题。
2. 对于一些只需要一个实例的情况十分有用

单例模式的缺点

1. 扩展性差，因为没有抽象层
2. 可能违背单一指责原则，因为其既充当了工厂的角色，又充当了产品的角色。

适用场景

1. 只需要一个实例对象，比如windows任务管理器
2. 只允许使用一个公共访问点，除了使用公共访问点外，无其他途径可访问。