单例模式的各种实现（懒加载、饿汉式、双重检验加锁）

单例设计模式： 顾名思义就是只有一个单例，所以此时必须将构造器私有化，不然外部还是可以创建多个对象实例的，因此只能在类内部创建一个实例变量，并且通过静态方法去获取该实例。

1. 饿汉式单例模式：调用getInstance方法就直接返回实例，等不及创建对象的过程。

public class Singleton {
    private static Singleton singleton = new Singleton();//类加载直接创建对象

    private Singleton() {
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

这种方式的缺点是如果这个对象没有被调用，就会浪费内存。

2. 懒加载单例模式（懒汉式）： 定义一个对象变量，等到调用getInstance方法时再判断变量是否为null，为null再创建对象。

public class Singleton {
    private static Singleton singleton;
    private Singleton() {
    }

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

这种方式的问题是多线程环境中线程不安全，一个线程判断为null创建对象时，还没初始化时，另一个线程判断也为null，此时就会创建多个实例。

解决方案：
（1） 将getInstance方法修改为synchronized修饰的同步方法：
public synchronized static Singleton getInstance() {
但是多个线程同时访问这个方法时会阻塞，性能很低。此时可以用第二种方案。
（2） 使用双重检验加锁实现单例模式懒加载

3. 双重检验加锁实现单例模式懒加载

直接上代码：

/**
 * 双重检查加锁实现单例模式懒加载
 * volatile:
 *      1. 保证可见性：对变量的修改会立刻刷新主存，并且对该变量的读取都会到主存中读取最新的值
 *      2. 防止指令重排
 *          当前创建对象的过程是
 *              1. 栈内存开启空间给对象引用
 *              2. 堆内存分配对象地址，并准备初始化对象
 *              3. 初始化对象
 *              4. 栈内存引用指向堆内存中对象地址
 *           优化之后可能会变成 1,2,4,3。此时栈空间已经引用了堆空间的地址，但是此时对象还没初始化，那么对象的使用可能就会抛出
 *           nullPointException.
 */
public class DoubleCheckImplementsSingleton {
    private volatile static DoubleCheckImplementsSingleton singleton;
    private DoubleCheckImplementsSingleton() {} //私有化构造器

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