单例模式详细探究

有些东西学完就忘，怎么办呢？
还能咋办，忘了再学呗！

前言

  我们为什么需要单例模式呢？每次都new一个对象不行吗？
  根据我这个快要毕业的、没有开发经验的菜鸟来看，内存是有数的，并不是无限的，所以单例模式是为了尽可能的节约资源，只有一个对象和频繁的创建对象，孰优孰略想想就知道。

饿汉式

  概念就是很神奇，一眼下去是个懵逼的词，等你弄懂了又发现这个词确实还挺形象准确。
  怎么实现单例？肯定不能随便让你new一个对象，把构造器私有化。那怎么获取对象呢？自然是暴露出来一个方法能够获取这个对象。首先我们来看这个饿汉式的实现方式。什么是饿汉式呢？就是当类加载完毕，对象就创建好了，不管你用不用，先给你创建上。我们看代码：

public class TaskManageHungry {
    
    private static TaskManageHungry taskManageHungry = new TaskManageHungry();
    //构造器私有
    private TaskManageHungry() {
        System.out.println("执行构造器===>");
    }
    //获取这个对象的方法
    public static TaskManageHungry getInstance(){
        return taskManageHungry;
    }
    //测试这个单例模式
	public static void main(String[] args) {
        TaskManageHungry taskManageHungry1 = TaskManageHungry.getInstance();
        TaskManageHungry taskManageHungry2 = TaskManageHungry.getInstance();
        TaskManageHungry taskManageHungry3 = TaskManageHungry.getInstance();
        System.out.println(taskManageHungry1);
        System.out.println(taskManageHungry2);
        System.out.println(taskManageHungry3);
    }
}

这样我们就实现了这个饿汉式的单例模式，每次都是同一个对象，我们可以运行看看。

  但是呢，这样虽然实现了单例模式，可它还是有点问题。怎么说呢，我们先回归一下单例模式的初心——节约资源。那假如这个对象我用的次数并不多，而且系统启动后很长时间我才能用得上这个对象，那它直接创建出来，很长时间不被使用，被它占用的那点内存不就浪费了吗？所以这就又引出了懒汉式单例。

懒汉式

  什么是懒汉式呢?就是我并不急着创建这个对象，只有当它第一次被调用的时候再创建这个对象。我们还是直接看代码

public class TaskManageLazy {

    private TaskManageLazy(){
        System.out.println("懒汉式构造器执行");
    }

    private static TaskManageLazy taskManageLazy;

    //获取实例
    public static TaskManageLazy getInstance(){
        if (taskManageLazy == null) {
            taskManageLazy = new TaskManageLazy();
        }
        return taskManageLazy;
    }

}

  我们在获取对象的方法里加一个判断，这样就实现了懒汉式单例。没人用的时候，它就是个null，有人调用了，才会创建对象。
  但是这样又出现了新的问题，比如我有十个线程，同时调用这个对象，十个线程都是第一次调用，那岂不是就又创建了好几个对象，单例模式就被破坏了，我们来看看这个多线程情况下会出现什么样的结果。

public static void main(String[] args) {
    //测试多线程下
    for (int i = 0; i < 10; i++) {
        new Thread(() -> System.out.println(TaskManageLazy.getInstance())).start();
    }
}

开十个线程来调用，我们来看运行结果。

这说明我们的懒汉式单例还是不够完善，那怎么才能在多线程情况下也能实现单例模式呢？当然是上锁。

public class TaskManageLazy {

    private TaskManageLazy(){
        System.out.println("懒汉式构造器执行");
    }

    private static TaskManageLazy taskManageLazy;

    //获取实例
    public static TaskManageLazy getInstance(){
        synchronized (TaskManageLazy.class) {
            if (taskManageLazy == null) {
                taskManageLazy = new TaskManageLazy();
            }
        }
        return taskManageLazy;
    }
}

这样锁起来确实可以保证线程安全，但是我们想一下，只有第一次执行的时候才需要加锁来创建对象。如果要是这样写，那我每次获取实例都要锁起来，不管有没有对象都要锁起来，假如我有一百个线程要获取这个对象，那这一百个线程岂不是要排队等待着一个个获取。所以，我们还要把它改造一下，没有对象的时候加锁，有对象了就直接返回。

public class TaskManageLazy {

    private TaskManageLazy(){
        System.out.println("懒汉式构造器执行");
    }

    private static TaskManageLazy taskManageLazy;

    //获取实例
    public static TaskManageLazy getInstance(){
        if (taskManageLazy == null){
            synchronized (TaskManageLazy.class) {
                if (taskManageLazy == null) {
                    taskManageLazy = new TaskManageLazy();
                }
            }
        }
        return taskManageLazy;
    }
}

这种方式就叫做双重检查锁。检查了两次null可不就是双重嘛。
  了解到这里其实也还行，不过我们能不能更深入一点呢？这样就真的安全了吗？假如有人用反射破坏了这个单例怎么办呢？有没有一种办法一劳永逸呢？
  这些事情，就以后再聊吧。