java设计模式 单例_Java设计模式（三）：单例模式

一、单例模式

在任何开发语言中，单例模式应该算是大家基乎最先接触和学习的设计模式，因为，它最为简单也最为常用。

单例模式的特点：

有且仅有一个实例；

构造方法为私有；

其实例只能由自己来创建；

单例模式的使用场景：

全局配置；

client端用户缓存；

等等；

单例也适时使用，不要觉得简单就乱用！

二、Java中的实现方式

大家能够用多少种方式来实现单例模式？

至少我能用5种方式来实现，如果还有更多其它方式，也欢迎在评论区留言。

2.1、简单暴力

/**

* 没有延迟加载，但却最简单

*/

public class Singleton {

private static final Singleton instance = new Singleton();

private Singleton(){}

public static Singleton getInstance(){

return instance;

}

}

2.2、延迟加载

针对 2.1 在类加载时就初始化，这里采用了延迟初始化。

/**

* 延迟加载

*/

public class Singleton {

private static Singleton instance = null;

private Singleton(){}

public synchronized static Singleton getInstance(){

if(instance == null){

instance = new Singleton();

}

return instance;

}

}

2.3、静态内部类来延迟加载

/**

* 静态内部类，加载时没有初始化 instance，因此达到了延迟加载

*/

public class Singleton {

private static class InternalSingleton{

private static final Singleton instance = new Singleton();

}

private Singleton(){}

public static Singleton getInstance(){

return InternalSingleton.instance;

}

}

2.4、双检索(DCL)

这种方式，大家要注意，网上有些是错误的。

public class Singleton {

private static volatile Singleton instance = null; // 这里需要 volatile

private Singleton(){}

public static Singleton getInstance(){

if(instance == null){

synchronized(Singleton.class){

if(instance == null){

instance = new Singleton();

}

}

}

return instance;

}

}

为何要加上 volatile ，大家可以去看我的《小白系列五：关键字volatile》。

2.5、枚举方式(JDK 1.5才支持)

public enum Singleton{

instance; // 默认 instance = this

public void function(){

// ......

}

}

三、五种方式的对比

3.1、绝对单实例

5种方式都能正确的实现单例，但只有『枚举方式』才是最为安全的，因此，它不支持反射，而其它方式虽然私有化了默认构造函数，但是，我们能可以通过反射的方式来产生多实例。

import java.lang.reflect.Constructor;

public class Demo {

public static void main(String[] args) {

Singleton singleton1 = Singleton.getInstance();

Singleton singleton2 = null;

try {

Constructor constructor = Singleton.class.getDeclaredConstructor();

constructor.setAccessible(true);

singleton2 = (Singleton) constructor.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("singleton1 = " + singleton1);

if (singleton2 != null) {

System.out.println("singleton2 = " + singleton2);

}

}

}

打印结果如下：

singleton1 = Singleton@610455d6

singleton2 = Singleton@511d50c0

我们可以看到，Singleton 变成了多实例。

而枚举则不允许反射，JDK 源码中有给出判断：

// java.lang.reflect.Constructor.java

public final class Constructor extends Executable {

.....

@CallerSensitive

public T newInstance(Object ... initargs)

throws InstantiationException, IllegalAccessException,

IllegalArgumentException, InvocationTargetException

{

if (!override) {

if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {

Class> caller = Reflection.getCallerClass();

checkAccess(caller, clazz, null, modifiers);

}

}

// 这里会判断类的修饰符，如果是枚举则报错

if ((clazz.getModifiers() & Modifier.ENUM) != 0)

throw new IllegalArgumentException("Cannot reflectively create enum objects");

ConstructorAccessor ca = constructorAccessor; // read volatile

if (ca == null) {

ca = acquireConstructorAccessor();

}

@SuppressWarnings("unchecked")

T inst = (T) ca.newInstance(initargs);

return inst;

}

......

}

3.2、内存消耗

相比较静态常量，枚举会稍微多消耗点内存，因为枚举首先还是一个类，然后实例化几个由 final 修饰这个类的对象，每个实例都带有自己的一些元信息。而常量没有这一层封装，只占用基本的内存(包括引用和它的值本身)，因此，要简单轻巧；如果值是基本类型而不是包装类型，那占用的内存就更少了。

枚举的使用，和单例的使用一样，我们也要适度，不能滥用；同样，大家在使用枚举时也不要担心这多出来的一点点内存开销，该用的时候还是要用。同时，我们需要注意一点：枚举的出现，能够帮助我们提升代码可读性，以及更好的可扩展性；因此，相比较多出来的一点点内存开销，不建议以牺牲代码可读性、可维护性、开发效率等而不使用枚举。

总之，Java的单例模式，我更推荐使用枚举来实现！