单例：从小白到入门

1、饿汉式

面试的时候，常常会被问到这样一个问题：请您写出一个单例模式（Singleton Pattern）吧。好吧，写就写，这还不容易。顺手写一个：`

public class SingletonHungry {
    
    private SingletonHungry(){}//私有化构造器
    
    private static final SingletonHungry INSTANCE =  new SingletonHungry(); //饿汉式 
    
    public static SingletonHungry getInstance(){
        return  INSTANCE;
    }
    
}

这种写法就是所谓的 饥饿模式，每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题：如果这个对象很大呢？没有使用这个对象之前，就把它加载到了内存中去是一种巨大的浪费。

2、懒汉式

针对上面这种情况，我们可以对以上的代码进行改进，使用一种新的设计思想—— 延迟加载（Lazy-load Singleton）。

public class SingletonLazy {

    private SingletonLazy(){}//私有化构造器

    private static  SingletonLazy instance = null;//懒汉式

    public static  SingletonLazy getInstance(){

        if(instance == null){
            instance = new SingletonLazy();
        }

        return instance;
    }

}

这种写法就是所谓的 懒汉模式。它使用了延迟加载来保证对象在没有使用之前，是不会进行初始化的。但是，通常这个时候面试官又会提问新的问题来刁难一下。他会问：这种写法线程安全吗？回答必然是：不安全。这是因为在多个线程可能同时运行到第10行，判断singObj为null，于是同时进行了初始化。所以，这是面临的问题是如何使得这个代码线程安全？很简单，在那个方法前面加一个Synchronized就OK了。

public class SingletonLazy {

    private SingletonLazy(){}//私有化构造器

    private static  SingletonLazy instance = null;//懒汉式

    public static synchronized SingletonLazy getInstance(){

        if(instance == null){
            instance = new SingletonLazy();
        }

        return instance;
    }
}

同步的代价必然会一定程度的使程序的并发度降低。那么有没有什么方法，一方面是线程安全的，有可以有很高的并发度呢？我们观察到，线程不安全的原因其实是在初始化对象的时候，所以，可以想办法把同步的粒度降低，只在初始化对象的时候进行同步。这里有必要提出一种新的设计思想—— 双重检查锁。

public class SingletonLazy {

    private SingletonLazy(){}//私有化构造器

    private static  SingletonLazy instance = null;//懒汉式

    public static synchronized SingletonLazy getInstance(){

        if(instance == null){
        
            synchronized (SingletonLazy.class){

                if(instance == null){

                    instance = new SingletonLazy();
                }

            }

        }

        return instance;
    }
}

这种写法还是有问题的！！问题在哪里？因为以下语句不是原子性操作：

instance = new SingletonLazy();

非原子性操作就可能发生指令重拍操作（例如1-3-2就会导致该对象没有完成初始化）：
1、分配内存空间
2、执行构造方法，初始化对象
3、把这个对象指向这个空间
所以加上volatile才算是完整的 ，简单来说，Volatile是Java虚拟机提供的轻量级的同步机制，它主要的作用如下：
1、保证可见性
2、不保证原子性（重要）
3、禁止指令重拍
但是由于Java反射机制的存在，所有的私有关键字、代码都是纸老虎。
没关系，兵来将挡水来土掩，请继续往下看。

内部类

这里又要提出一种新的模式—— Initialization on Demand Holder. 这种方法使用内部类来做到延迟加载对象，在初始化这个内部类的时候，JLS(Java Language Sepcification)会保证这个类的线程安全。这种写法最大的美在于，完全使用了Java虚拟机的机制进行同步保证，没有一个同步的关键字。

public class InnerClass {

    private static class  Inner{

        private static final Inner INSTANCE = new Inner();

    }

    public static  Inner getInstance(){
        
        return Inner.INSTANCE;
    }

}

枚举单例

public enum  EnumSingleton {

    INSTANCE;

    public static EnumSingleton getInstance(){

        return INSTANCE;

    }


}

枚举本身也是一个类，利用jad反编译工具，可以发现，默认构造器不是空参构造方法，真实的是带两个参数

String s, int i

使用反射创建对象会报错，因为JDK规定反射不能破坏枚举的单例。

java.lang.IllegalArgumentException: Cannot reflectively create enum objects

拓展：

也可以使用HashMap用于做为单例对象池，通过newInstance()实例化对象（不支持带参数的构造方法），无论取还是创建对象都是线程安全的（在单例对象数量非常庞大且单例对象实例化非常耗时时可能会出现瓶颈），这里就不详细介绍了。

本篇文章简单介绍了单例模式的几种实现方式，希望对大家有帮助。