设计模式（一）------单例模式

介绍

这种模式只涉及到一个单一的类，该类负责创建自己的对象，并确保只创建一个对象。

单例只有一个实例；
单例类必须创建自己唯一的实例；
单例类必须给其他对象提供这唯一的实例；

分类

由于当今的编程模型都是基于多线程方式，因此此处只介绍线程安全的几种实现。

懒汉型

第一次被调用时才创建对象，属于懒加载（Lazy-Init）， 节约一定的内存，但由于需要增加同步锁，因此性能会低一些。

public class LazySingleton {

    private static LazySingleton lazySingleton;

    public static synchronized LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }

}

饿汉型

类加载时就创建对象，不属于懒加载（Lazy-Init），因此会有一定的内存损耗，但不适用同步锁，因此性能会高一些。

public class HungrySingleton {

    private static HungrySingleton hungrySingleton = new HungrySingleton();

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }

}

双重锁型

采用双重锁的机制，属于懒加载（Lazy-Init），既能保证线程安全，也不过多损失性能。

public class DubbleLockSingleton {

    private static volatile DubbleLockSingleton dubbleLockSingleton;

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

}

静态内部类型

比双重锁实现简单，比饿汉型更节省资源，因为是内部类被调用时才创建对象。

public class StaticInternalSingleton {

    private static class StaticInternalSingletonHolder {

        private static StaticInternalSingleton INSTANCE = new StaticInternalSingleton();

    }

    public static StaticInternalSingleton getInstance() {

        return StaticInternalSingletonHolder.INSTANCE;

    }

}