关于java中的单例模式（饿汉式，懒汉式，线程同步，DCL双重检验锁，指令重排）

本文是根据作者自己的学习思路梳理单例模式的知识点

什么是单例模式？

单例模式是指在开发中一些特殊的类只能创建一个对象，在代码运行的过程中，共享这一个对象，不能（也无法）再次创建。

最简单的单例模式举例

public class SingletonTest01 {
    public static void main(String[] args) {
        Sun instance1 = Sun.getInstance();
        Sun instance2 = Sun.getInstance();

        System.out.println(instance1 == instance2);//true
    }
}

class Sun {
    private static Sun sun = new Sun();

    private Sun(){}

    public static Sun getInstance(){
        return sun;
    }
}

实现方式

在本段代码中创建了一个Sun的类，这个类只能够创建一个对象，实现方式：

1.将构造方法私有化，这样外部无法直接new对象
2.给一个静态变量，这个静态变量实际上是Sun类的实例对象
3.给出一个获取这个实例对象的方法

这样做了以后，外部就只能通过getInstance()方法来获取本类的静态变量，也即实例对象sun，而这个静态变量在类加载时就已经创建好了，所以即使多次调用此方法，返回的也是同一个sun。

这就是最简单的单例模式的构建

饿汉式单例模式

分析上述代码可以看到，Sun类的实例对象，是通过初始化静态变量得到的，即在类加载时就new出Sun的实例对象，这就像一个饿了很久的流浪汉，刚刚看到自己需要的类就迫不及待地new出了一个对象，这就称为饿汉式单例模式。
这里对比懒汉式单例模式会清楚很多。

懒汉式单例模式

有的时候，你可能会想在需要的时候再创建该对象，这就需要对上述代码进行细微的改动。

class Sun {
    private static Sun sun;

    private Sun(){}

    public static Sun getInstance(){
    	if(sun == null) sun = new Sun();//在这里创建该对象
    	return sun;
    }
}

上述代码是在调用getInstance()方法时创建该对象，而饿汉式单例模式是在类加载时创建该对象，这就是懒汉式单例模式。
-----------------☝但是此时所写的懒汉式单例模式是有缺陷的☝---------

线程同步改进饿汉式单例模式（DCL双重检验锁）

上面写的懒汉式单例模式在多线程并发的情况下可能会出问题，有可能会创建出多个对象。下面进行测试。

public class SingletonTest02 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            Sun sun = Sun.getInstance();
            System.out.println(sun);
        });
        Thread t2 = new Thread(()->{
            Sun sun = Sun.getInstance();
            System.out.println(sun);
        });
        Thread t3 = new Thread(()->{
            Sun sun = Sun.getInstance();
            System.out.println(sun);
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

很明显这里由于多线程并发创建了多个对象。

那该如何解决这个问题呢？解决多线程并发问题我们首先想到synchronized关键字，于是可以给Sun类的getinstance()方法加上关键字。
再次测试就不会出现问题了，这里为了更明显的显示接下来的问题，在方法中加入一段延迟。

public synchronized static Sun getInstance(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (sun == null) {
            sun = new Sun();
        }
        return sun;
    }

再次执行测试代码。

这里就不会出现创建多个对象的问题了。

但是这里因为getInstance()方法用synchronized关键字修饰，所以整段测试代码运行下来大概需要九秒的时间，效率较低。

于是可以把创建对象的过程同步进行，而不是同步整个方法。

public static Sun getInstance(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized (Sun.class){
            if (sun == null) {
                sun = new Sun();
            }
        }
        return sun;
    }

这样可以进一步优化代码的执行效率。

同样的，这里在每次获取对象之前都要获取锁，这会导致并发性能降低，于是可以在同步代码块外层加一层判断。

if (sun == null) {
    synchronized (Sun.class){
        if (sun == null) {
            sun = new Sun();
        }
    }
}
return sun;

这样就解决了性能低下的问题。

可以看到，这里在同步代码块外和同步代码块内进行了两次判空，这种懒汉式写法叫做双重检验锁（Double Check Lock）。

上面的代码已经接近完美了，但是还存在最后一个问题，指令重排。
这个问题还没搞清楚，日后再修改。