单例模式五种实现方式

应用场景：

封装一些常用的工具类，保证整个应用常用的数据统一；

保存一些共享数据在内存中，其他类可以随时读取。

Runtime类、一个系统的登录人数统计。

1、饿汉式

package com.xiaofeng.test;
 
public class HungerSingleton {
 
    /**
     * 私有的构造器
     */
    private HungerSingleton() {
    }
 
    /**
     * 私有的实例
     */
    private static HungerSingleton instance = new HungerSingleton();
 
    /**
     * 对外提供访问方法
     *
     * @return
     */
    public static HungerSingleton getSingleton() {
        return instance;
    }
}

在类被加载的时候就把Singleton实例给创建出来了。

饿汉式的缺点就是，可能在还不需要此实例的时候就已经把实例创建出来了，没起到lazy loading的效果。优点就是实现简单，而且安全可靠。

2、懒汉式

package com.xiaofeng.test;
 
public class LazySingleton {
 
    /**
     * 私有的构造器
     */
    private LazySingleton() {
    }
 
    /**
     * 私有的实例
     */
    private static LazySingleton instance = null;
 
    /**
     * 对外提供访问方法
     * @return
     */
    public static LazySingleton getSingleton() {
        if (null == instance) {
            instance = new LazySingleton();
        }
        return instance;
    }
 
}

在真正需要的时候再去创建实例。在getInstance方法中，先判断实例是否为空再决定是否去创建实例，看起来似乎很完美，但是存在线程安全问题。在并发获取实例的时候，可能会存在构建了多个实例的情况。

3、双重检锁

package com.xiaofeng.test;
 
public class DoubleCheckLockSingleton {
 
    private DoubleCheckLockSingleton() {
    }
 
    private static volatile DoubleCheckLockSingleton instance;
 
    public DoubleCheckLockSingleton getSingleton() {
        if (null == instance) {
            synchronized (DoubleCheckLockSingleton.class) {
                if (null == instance) {
                    instance = new DoubleCheckLockSingleton();
                }
            }
        }
        return instance;
    }
}

对懒汉式单例模式做了线程安全处理。通过加锁，可以保证同时只有一个线程走到第二个判空代码中去，这样保证了只创建一个实例。这里还用到了volatile关键字来修饰singleton，其最关键的作用是防止指令重排。

4、静态内部类

package com.xiaofeng.test;
 
public class StaticInnerClassSingleton {
 
    private StaticInnerClassSingleton() {
    }
 
    private static class InnerClass {
        private final static StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }
 
    public static StaticInnerClassSingleton getInstance() {
        return InnerClass.INSTANCE;
    }
 
}

过静态内部类的方式实现单例模式是线程安全的，同时静态内部类不会在Singleton类加载时就加载，而是在调用getInstance()方法时才进行加载，达到了懒加载的效果。可能还存在反射攻击或者反序列化攻击。

5、枚举

package com.xiaofeng.test;
 
public enum EnumSingleton {
 
    INSTANCE;
 
    public void doSomething() {
        System.out.println("doSomething");
    }
}