简介

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。即一个类只有一个对象实例。

使用场景

单例模式可以实现在整个应用中只存在单一实例的功能，对于 Java 来说，单例模式可以保证在一个 JVM 中，只存在单一的实例。而要求只有单一实例这种应用的场景主要有以下几个方面：

• 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少GC；
• 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用；
• 频繁访问数据库或文件的对象；
• 对于一些控制硬件级别的操作或者从系统上来讲应当是单一的控制逻辑的操作，如果有多个实例的话，系统就会完全乱套；

代码展示

Java 中四种单例模式的各个写法如下：

1. 懒汉式

public class LazySingleton {
    private static volatile LazySingleton sInstance;

    private LazySingleton() {
    }

    public static LazySingleton getInstance() {
        LazySingleton inst = sInstance;
        if (inst == null) {
            synchronized (LazySingleton.class) {
                inst = sInstance;
                if (inst == null) {
                    inst = new LazySingleton();
                    sInstance = inst;
                }
            }
        }
        return inst;
    }
}

懒汉式，懒又为懒加载，延迟加载之意。所以上面的示例采用的是双重加锁的方式实现单例的延迟实例化，只有明确调用getInstance()时才会实例化对象，这样就达到了懒加载的目的。

2. 饿汉式

public class StarveSingleton {
    private static final StarveSingleton sInstance = new StarveSingleton();

    private StarveSingleton() {
    }

    public static StarveSingleton getInstance() {
        return sInstance;
    }
}

饿汉式，饿即饿虎扑狼，立即，马上之意。也就是说在类加载的时候，就立即实例化对象。上面的示例由于 classloader 的机制，天然避免了多线程同步的问题，这种单例写法在类被装载的时候，sInstance就会被创建，没有延迟加载的效果。

3. 静态内部类

public class InnerSingleton {
    private InnerSingleton() {
    }

    private static class SingletonHolder {
        private static final InnerSingleton sInstance = new InnerSingleton();
    }

    public static final InnerSingleton getInstance() {
        return SingletonHolder.sInstance;
    }
}

上面示例同样通过 classloader 机制天然避免了多线程同步问题，同时，采用了静态内部类后，使得该单例模式具备延迟加载特性，因为InnerSingleton加载并不会导致SingletonHolder被加载，所以并未发生new InnerSingleton过程，一般只有在显示调用InnerSingleton.getInstance()时，InnerSingleton才会被加载，同时导致InnerSingleton被创建。

4. 枚举

//我们实际需要单例的类
public class RealSingleton {
    private RealSingleton(){
    }

    private enum EnumSingleton {
        INSTANCE;
        private final RealSingleton singleton;
    
        EnumSingleton() {
            singleton = new RealSingleton();
        }
    }

    public static RealSingleton getInstance() {
        return EnumSingleton.INSTANCE.singleton;
    } 
}

采用枚举的单例模式，不仅能够避免多线程同步的问题，而且还能防止反序列化或者反射重新创建新的实例，调用方式为：EnumSingleton.INSTANCE.getInstance()，Effective Java 里面有句话：

单元素的枚举类型已经成为实现Singleton的最佳方法。

总结一下：
如果需要延迟加载，可以选择: 懒汉式，静态内部类，枚举
否则，使用：饿汉式

下一篇：工厂模式