单例模式的写法

1. 什么是单例模式

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，单例模式一般会屏蔽构造器，另外为单例对象提供一个全局访问点，单例模式属于创建型模式。

2. 九种单例模式

1. 饿汉式单例

   饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。因为在线程还没出现以前对象就被实例化了，所以其线程绝对安全，不可能存在访问安全问题。

 	private static final Object o = new Object();
    private Object() {
    }
    public static Object getInstance(){
        return o;
    }

或者

	private static final Object o;
    static {
         o = new Object();
    }
    private Object() {
    }
    public static Object getInstance(){
        return o;
    }

饿汉式单例的优缺点

• 优点：创建对象时没有加任何的锁、执行效率比较高。
• 缺点：也很明显，因为其在类加载的时候就初始化了，也就是说不管我们用或者不用都占着空间，如果项目中有大量单例对象，则可能会浪费大量内存空间。

2. 懒汉式单例

• 类加载的时候不会初始化，而是等到需要用到单例对象了才会进行初始化。

	private static MyObject my = null;
    private MyObject() {
    }
    public static MyObject getInstance(){
        if(null == my){//为空则说明第一次获取单例对象，进行初始化
            my= new MyObject();
        }
        return my;//不为空则说明已经初始化了，直接返回
    }

在调用 getInstance 方法的时候才会去初始化单例对象。但是存在线程安全问题，多线程情况下会有一定几率返回多个单例对象，这明显违背了单例对象原则。

• 不违背单例对象原则加锁就可以了：

	private static MyObject my = null;
    private MyObject() {
    }
    public synchronized static MyObject getInstance(){
        if(null == my ){
            my = new MyObject ();
        }
        return my;
    }

• 假如单例对象的创建非常复杂耗时的情况下，一旦并发量上来了，CPU 压力上升，那么就可能会导致大批量线程出现阻塞，从而导致程序运行性能大幅下降。双重检查锁（double-checked locking）单例写法;
  my 属性加上volatile 关键字，其他线程就可以感知到;
  把 synchronized 关键字移到了方法内部，尽可能缩小加锁的代码块，提升效率;

	private volatile static MyObject my = null;
    private MyObject() {
    }
    public static MyObject getInstance(){
        if(null == my ){
            synchronized (MyObject.class){
                if(null == my ){
                    my = new MyObject();
                }
            }
        }
        return my;
    }

这样写还是有问题，涉及到了指令重排序的概念了。
new 对象只有一行代码，然而这一行代码在 JVM 底层却分成了 3 步：

分配内存来创建对象，即：new。
创建一个对象 my，此时 my == null。
将 new 出来的对象赋值给 my。

• 这 3 步并不会按照实际顺序来运行的。那我们打个比方，假如有一个线程 t1 进入同步代码块正在创建对象，而此时执行了上面 3 个步骤中的后面 2 步，也就是说这时候 lazySingleton 已经不为 null 了，但是对象却并没有创建结束；此时又来了一个线程 t2 进入 getInstance 方法，这时候 if 条件肯定不成了，线程 t2 会直接返回，也就相当于返回了一个残缺不全的对象，这时候代码就会报错了。

 	private MyObject(){
    }
    public static final MyObject getInstance(){
        return InnerLazy.LAZY;
    }
    private static class InnerLazy{
        private static final MyObject LAZY = new MyObject();
    }

利用了内部类会等到外部调用时才会被初始化的特性，用饿汉式单例的思想实现了懒汉式单例。但是仍然可以利用反射来破坏单例。

	private MyObject(){
        //防止反射破坏单例
         if(null != InnerLazy.LAZY){
           throw new RuntimeException("不允许通过反射类构造单例对象");
         }
    }
    public static final MyObject getInstance(){
        return InnerLazy.LAZY;
    }
    private static class InnerLazy{
        private static final MyObjectLAZY = new MyObject();
    }

这样就不会被反射破坏单例，但是如果实现了Serializable 接口，那么内部类的写法就还是能通过序列化来破坏。如此加上readResolve方法防止序列化

	private Object readResolve(){
        return InnerLazy.LAZY;
    }

3. 注册式单例

   注册式单例就是将每一个实例都保存起来，然后在需要使用的时候直接通过唯一的标识获取实例。Spring 框架中用的就是容器式单例，默认是线程不安全的。

 	private MyObject(){
    }
    private static Map<String,Object> ioc = new ConcurrentHashMap<>();//存储单例对象
    public static Object getBean(String className){
        synchronized (ioc){
            if(!ioc.containsKey(className)){//如果容器中不存在当前对象
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className,obj);//将className作为唯一标识存入容器
                }catch (Exception e){
                    e.printStackTrace();
                }
                return obj;
            }
            return ioc.get(className);//如果容器中已经存在了单例对象，则直接返回
        }
    }

4. ThreadLocal 式单例

   ThreadLocal 式单例不能保证其创建的对象是全局唯一，但是能保证在单个线程中是唯一的，在单线程环境下线程天生安全。

 	private MyObject() {
    }
    private static final ThreadLocal<MyObject> singleton =
            new ThreadLocal<MyObject>() {
                @Override
                protected MyObject initialValue() {
                    return new MyObject();
                }
            };
    public static MyObject getInstance(){
        return singleton.get();
    }

5. 枚举式

   枚举式单例充分利用了枚举类的特性来创建单例对象，目前来说这是最优雅的一种写法。

	public enum EnumSingleton {
    INSTANCE;
    private MyObject myObject;
    EnumSingleton() {
        this.myObject = new MyObject();
    }
    public Object getData() {
        return myObject;
    }
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}