设计模式--01.单例模式

在程序设计中，需要保证一个只有一个对象实例，就是所谓的单例模式。在java中，有很多单例模式的实现，这篇博客是对这几种单例模式的优缺点进行分析和优化：

饿汉模式

---

所谓饿汗模式，就是优先创建对象，对象在类加载的时候就已经创建好了，具体的代码如下：

    private static Singleton01 instance = new Singleton01();

    public static Singleton01 getInstance() {
        return instance;
    }

`

饿汗模式优点是代码简单，由于是在类加载的时候就已经创建好了对象，所以不存在线程安全的问题。

缺点是：有的类在没有使用的时候就已经创建了对象，产生了多余的垃圾对象。

---

懒汉模式

---

懒汉模式是针对饿汉模式的一个优化，类只有在使用的时候才会进行实例化：

    private static Singleton02 instance;
    //懒汉模式
    //简单，但是线程不安全
    public static Singleton02 getInstance() {
        if (instance == null) {
            instance = new Singleton02();
        }
        return instance;
    }

懒汉模式的实例在使用的时候才去创建，但是创建的过程是线程不安全的，在多线程的环境下存在多个实例的现象。

---

double check模式

---

doublie check模式优化了懒汉模式的线程安全的问题，使用锁来保证当前只有一个线程创建实例。

   private static Singleton03 singleton03;

    //加锁，线程安全，但是效率慢
    public synchronized static Singleton03 getInstance() {
        if (singleton03 == null) {
            singleton03 = new Singleton03();
        }
        return singleton03;
    }

上面的代码足够保证了线程的安全，但是多线程的场景下会存在一个线程工作，其他线程盲等的现象，所以再为了优化这个问题，再创建进入锁之前再次进行检查， 使用volatile关键字保证变量在多线程中是共享的，代码如下：

private volatile static Singleton05 singleton05;
    //double check 性能最好
    public static Singleton05 getInstance() {
        if (singleton05 == null) {
            synchronized (Singleton05.class) {
                if (singleton05 == null) {
                    singleton05 = new Singleton05();
                }
            }
        }
        return singleton05;
    }

虽然doublecheck的模式，继承了懒汉模式的优点，也不会有线程安全的问题，但还是会存在线程盲等的现象，优化只能降低发生的概率，无法完全避免。

---

内部类模式

---

内部类模式是一个比较精妙的设计，是利用了Jvm的类的加载的特点，具体代码如下：

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

    static class Inner {
        final  static Singleton06 INSTANCE = new Singleton06();
    }

只有第一次调用getInstance方法时，虚拟机才加载 Inner 并初始化instance ，只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性。目前此方式是所有单例模式中最推荐的模式。
缺点是会产生多余的类，反射也可以破解,通过构造函数可以防止破解。

---

枚举单例模式

---

枚举是《effective java》中推荐的单例模式，利用jvm的枚举类无法被反射的创建实例的特点，所以枚举类相对更加安全和健壮。具体的代码如下:

    public enum Singleton07 {
        INSTANCE;
        Singleton07() {
            System.out.println(this.getClass().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

虽然枚举模式有点很多，但是再实际开发中却用的很少，原因是枚举类的用法比较单一（不支持继承）。

---

使用memoize创建单例

---

使用Guava的memoize函数的特性， 只再第一此获取的时候才调用，可以用来实现单例模式，代码如下：

private static final Supplier<Singleton08> InstanceSuppler = Suppliers.memoize(Singleton08::new);

    public static Singleton08 getInstance() {
        return InstanceSuppler.get();
    }

使用memoize函数，可以支持多种的实例函数的调用方式，也可以制定方法的过期的时间，更为灵活，个人推荐使用memoize方式