单例模式

最新推荐文章于 2023-07-08 13:40:10 发布

原创最新推荐文章于 2023-07-08 13:40:10 发布 · 161 阅读

0 ·

CC 4.0 BY-SA版权

单例模式是很常用的一个模式，通常我们希望整个系统中只存在一个实例的时候，单例模式便派上了用场，接下来我们看一下单例的几种实现方法以及利弊。

文章目录

饿汉式单例

饿汉式单例是说该单例模式就如同一个饥饿的汉子一样，先创建一个实例出来，不管是否有用到，这种方式简单暴力，缺点也显而易见，如果一直没有用这个实例的话，是对内存的一种浪费。
具体实现如下：

public class HungrySigleton {

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

懒汉式单例

懒汉式单例与饿汉式单例刚好相反，这位兄弟懒得很，直到用的时候，才去创建实例出来。这种方式没有浪费内存的情况，却因为在使用的时候才创建，防止创建多个实例，而需要加锁操作。这样每次去获取的时候到要先获得锁，如果同时有多个线程使用的话，会有严重的效率问题。
代码如下：

public class LazySigleton {

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

双重检查模式

鉴于饿汉式单例浪费内存，懒汉式单例效率低下，人们想到了是否能够先检查该对象是否已经创建，如果没有创建，才去加锁创建，否则直接获取实例。这样即不会浪费内存，而且效率也比较高。该方式书写单例缺点是比较麻烦，并且只有在jdk1.5以后volatile语义增强以后，该方式才能配合volatile关键字安全的创建实例。
代码如下：

public class DoubleCheckSigleton {

	private static volatile DoubleCheckSigleton instance;
	
	private DoubleCheckSigleton()
	{
	}
	
	public static DoubleCheckSigleton getInstance()
	{
		if(null == instance) //1
		{
			synchronized(DoubleCheckSigleton.class)
			{
				if(null == instance) //2
				{
					instance = new DoubleCheckSigleton();
				}
			}
		}
		return instance;
	}
}

该方式创建单例需要配合volatile关键字，因为new一个对象并不是原子操作，且内部可能出现重排序。创建一个对象需要以下三个步骤：

申请内存空间
变量属性赋值
将对象指向内存
由于JVM虚拟机允许不改变程序运行结果的情况下，对代码执行顺序进行重排序。所以上边三个步骤可能出现132的执行顺序。
假设线程A先执行了13两个步骤，然后线程B执行代码1处的判断，发现instance不为空返回，此时B线程返回的只是未创建完成的半个对象。
解决上述问题就需要使用volatile关键字，volatile关键禁止了上边23两步的重排序，所以能够正确创建并使用对象。

内部类方式单例

基于上边可能出现的重排序情况，添加volatile关键字是禁止重排序，另一种方式就是我们让这个重排序外部不可见。这就需要使用到内部类方式的延迟初始化。静态内部类只有在真正使用的时候才会加载，并且在初始化的时候虚拟机会为其加锁，保证类只会初始化一次。这样即能实现延迟初始化，又是线程安全的，书写简单。是强烈推荐的一种写法。
代码如下：

public class InnerClassSigleton {

	private InnerClassSigleton()
	{
	}
	
	public static InnerClassSigleton getInstance()
	{
		return InstanceHolder.instance;
	}
	
	private static class InstanceHolder
	{
		public static InnerClassSigleton instance = new InnerClassSigleton();
	}
}

枚举类

枚举类也是利用虚拟机的类初始化的线程安全来实现的，该方式的单例模式实现简单。
代码如下：

public enum EmunSigleton {
	instance;
}

是不是很简单，只有一行。那枚举类是怎么实现初始化的呢？我们看一下javap生成的反编译文件。

Compiled from "EmunSigleton.java"
public final class com.rdyang.designPattern.sigleton.EmunSigleton extends java.lang.Enum<com.rdyang.designPattern.sigleton.EmunSigleton> {
  public static final com.rdyang.designPattern.sigleton.EmunSigleton instance;

  static {};
    Code:
       0: new           #1                  // class com/rdyang/designPattern/sigleton/EmunSigleton
       3: dup
       4: ldc           #12                 // String instance
       6: iconst_0
       7: invokespecial #13                 // Method "<init>":(Ljava/lang/String;I)V
      10: putstatic     #17                 // Field instance:Lcom/rdyang/designPattern/sigleton/EmunSigleton;
      13: iconst_1
      14: anewarray     #1                  // class com/rdyang/designPattern/sigleton/EmunSigleton
      17: dup
      18: iconst_0
      19: getstatic     #17                 // Field instance:Lcom/rdyang/designPattern/sigleton/EmunSigleton;

是不是其实很熟悉，枚举类本质是一个继承了Emun的类，内部的属性是public static final类型的，这样，由虚拟机保证该类只有一个实例。

以上，便是全部的单例模式的写法，其中，最常用、也是最推荐的一种写法，便是静态内部类的写法。这种方法简洁，性能高。当然，枚举类的方式也是很不错的一个选择，具体怎样书写，就看个人意愿了。