单例模式的创建（Java版）

最新推荐文章于 2024-09-17 11:13:39 发布

置顶 hardor

最新推荐文章于 2024-09-17 11:13:39 发布

阅读量1.8k

点赞数 3

分类专栏：设计模式 java 文章标签： java 设计模式单例模式

本文链接：https://blog.csdn.net/Hardor/article/details/51203558

版权

设计模式同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

java

2 篇文章 0 订阅

订阅专栏

1.单例模式介绍

单例模式是应用最广的模式之一，也可能是很多初级工程师唯一会使用的设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为。如在一个应用中，应该只有一个ImageLoader实例，这个ImageLoader中又含有线程池、缓存系统、网络请求等，很消耗资源，因此，没有理由让它构造多个实例。这种不能自由构造对象的情况，就是单例模式的使用场景。

2.单例模式的定义

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

3.单例模式的使用场景

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。例如，创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源，这时就要考虑使用单例模式。

4.单例模式UML类图

图 4-1单例模式UML类图

角色介绍：

（1）Client——高层客户端；

（2）Singleton——单例类。

实现单例模式主要有如下几点关键点：

（1）构造函数不对外开放，一般为private；

（2）通过一个静态方法或者枚举返回单例类对象；

（3）确保单例类的对象有且只有一个，尤其是在多线程环境下；

（4）确保单例类对象在反序列化时不会重新构建对象。

通过将单例类的构造函数私有化，使得客户端代码不能通过new的形式手动构造单例类的对象。单例类会暴露一个公有静态方法，客户端需要调用这个静态方法获取到单例类的唯一对象，在获取这个单例对象的过程中需要确保线程安全，即在多线程环境下构造单例类的对象也是有且只有一个，这也是单例模式实现中比较困难的地方。

5.单例模式的实现方式

1、饿汉模式

public class Singleton{
	private static Singleton instance = new Singleton();
	private Singleton(){ }
	public static Singleton getInstance(){
		return instance;
	}
}

2、懒汉模式

懒汉模式是声明一个静态对象，并且在用户第一次调用getInstance时进行初始化，而饿汉模式是在声明静态对象时就已经初始化。

public class Singleton{
	private static Singleton instance = null;
	private Singleton(){ }
	public static synchronized Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}
}

getInstance()方法中添加了synchronized关键字，也就是getInstance是一个同步方法，这就是上面所说的在多线程情况下保证单例对象唯一性的手段。细想一下，大家可能会发现一个问题，即使instance已经被初始化（第一次调用时就会被初始化instance），每次调用getInstance方法都会进行同步，这样会消耗不必要的资源，这也是懒汉单例模式存在的最大问题。

最后总结一下，懒汉单例模式的优点是单例只有在使用时才会被实例化，在一定程度上节约资源；缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是每次调用getInstance都进行同步，造成不必要的同步开销。这种模式一般不建议使用。

3、Double CheckLock(DCL)实现单例

DCL方式实现单例模式的优点是既能够在需要时才初始化单例，又能保证线程安全，且单例对象初始化后调用getInstance不进行同步锁。

public class Singleton{
	private static Singleton instance = null;
	private Singleton(){ }
	public static Singleton getInstance(){
		if(instance == null){                     ①
			synchronized(Singleton.class){    ②
				if(instance == null){     ③
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

本程序的亮点自然都在getInstance方法上，可以看到getInstance方法中对instance进行了两次判空：第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。这是什么意思呢？是不是有点摸不着头脑，下面就一起来分析一下。

假设有两个线程A，B通过了①，假设线程A获得了同步锁进行初始化，那此时线程B就在②处阻塞了，等到线程A完成instance初始化后释放锁，此时instance不为空。与此同时，线程B在②处获得锁，如果没有③处的判断，instance会再进行一次初始化，这就违背了单例模式只实例化一次的原则。

假设线程A执行到instance= new Singleton()语句，这里看起来是一句代码，但实际上它并不是一个原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事情：

（1）给Singleton的实例分配内存；

（2）调用Singleton()的构造函数，初始化成员字段；

（3）将instance对象指向分配的内存空间(此时instance就不是null了)。

但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM（JavaMemory Model，即Java内存模型）中Cache、寄存器到主存回写顺序的规定，上面的第二和第三的顺序是无法保证的。也就是说，执行顺序可能是1-2-3也可能是1-3-2.如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候instance因为已经在线程A内执行过了第三点，instance已经是非空了，所以，线程B直接取走instance，再使用时就会出错，这就是DCL失效问题，而且这种难以跟踪难以重现的错误很可能会隐藏很久。

在JDK1.5之后，SUN官方已经注意到这种问题，调整了JMM、具体化volatile关键字，因此，如果JDK是1.5或之后的版本，只需要将instance的定义改成private volatile static Singleton instance = null就可以保证instance对象每次都是从主存中读取，就可以使用DCL的写法来完成单例模式。当然，volatile或多或少也会影响到性能，但考虑到程序的正确性，牺牲这点性能还是值得的。

DCL的优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。缺点：第一次加载反应稍慢，也由于Java内存模型的原因偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。DCL模式是使用最多的单例实现方式，它能够在需要时才实例化单例对象，并且能够在大多数场景下保证单例对象的唯一性，除非你的代码在并发场景比较复杂或者低于JDK1.5版本下使用，否则，这种方式一般能够满足需求。

4、静态内部类

DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题，但是，它还是在某些情况下失效的问题。这个问题被称为双重检查锁失效。建议用静态内部类替换。

public class Singleton{
	private Singleton(){ }
	public static  Singleton getInstance(){
		return SingletonHolder.instance;
	}
	private static class SingletonHolder{
		private static final Singleton instance = new Singleton();
	}
}

当第一次加载Singleon类时并不会初始化instance，只有在第一次调用Singleton的getInstance方法时才会导致instance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，所以这是推荐使用的单例模式实现方式。

5、枚举

public enum SingletonEnum{
	INSTANCE;
	public void doSomething(){
		System.out.println("do sth.");
	}
}

写法简单是枚举单例最大的优点，枚举在Java中与普通类一样，不仅有字段，还可以有自己的方法。最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

通过序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而有效得获得一个实例。即使构造函数是私有的，反序列化时依然可以通过特殊的途径去创建类的一个新的实例，相当于调用该类的构造函数。反序列化操作提供了一个很特别的钩子函数，类中具有一个私有的、被实例化的方法readResolve()，这个方法可以让开发人员控制对象的反序列化。例如，上诉几个示例中如果要杜绝单例对象在被反序列化时重新生成对象，那么必须加入如下方法：

private Object readResolve() throws ObjectStreamException{
	return instance;
}

也就是在readResolve方法中将instance对象返回，而不是默认的重新生成一个新的对象。而对于枚举，并不存在这个问题，因为即使反序列化它也不会重新生成新的实例。

6、使用容器

public class SingletonManager{
	private static Map<String,Object> objMap = new HashMap<String,Object>();
	private SingletonManager(){ }
	public static void registerService(String key,Object instance){
		if(!objMap.containsKey(key)){
			objMap.put(key, instance);
		}
	}
	public static Object getService(String key){
		return objMap.get(key);
	}
}

在程序的初始，将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。