【设计模式基础】创建型模式 - 1 - 单件(Singleton)

最新推荐文章于 2022-04-24 22:01:34 发布

王晓斌

最新推荐文章于 2022-04-24 22:01:34 发布

阅读量888

点赞数

分类专栏： Design Patterns 文章标签：设计模式 Design Patterns 创建型模式单件 Singleton

本文链接：https://blog.csdn.net/robinjwong/article/details/17674667

版权

Design Patterns 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1. 模式意图

保证类仅有一个实例，并提供一个访问它的全局访问点。

2. 模式定义

Singleton: 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作；可能负责创建它自己的唯一实例；客户只能通过Singleton的Instance操作访问一个Singleton的实例。

3. 模式实现

3.1 Java实现

当设计一个单件类的时候，会在类的内部构造这个类，并对外提供一个static getInstance方法提供获取单件对象的途径：

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

这样代码的缺点是：第一次加载类的时候会连带着创建Singleton实例，这样的结构与我们期望的不同，因为创建实例的时候可能并不是我们需要这个实例的时候。同时，如果这个Singleton实例的创建非常消耗系统资源，而应用始终都没有使用Singleton实例，那么创建Singleton消耗的系统资源就被白白浪费了。

为了避免这种情况，通常使用惰性加载的机制，也就是在使用的时候才去创建。

惰性加载：

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

这样当我们第一次调用Singleton.getInstance()的时候,这个单件才被创建.

惰性加载在多线程中的问题:

如果两个线程A和B同时执行了getInstance方法，然后以如下方式执行：

A进入if判断，此时instance为null，进入if内
B进入if判断，此时A还没有创建instance,因此B也进入if内
A创建一个instance并返回
B创建一个instance并返回

此时问题出现了，我们的单件被创建了两次，而这并不是我们所期望的。

各种解决方案及其存在的问题：

1. 使用class锁

给getInstance方法加上一个synchronized前缀，这样每次只允许一个线程调用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方法的时候都必须获得Singleton的锁，而实际上，当单件实例被创建以后，其后的请求就没有必要再使用互斥机制了。

2. double-checked locking双重检查加锁

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

首先当一个线程发出请求后，会先检查instance是否null，如果不是则直接返回其内容，这样避免进入synchronized块所需要花费的资源。其次，两个线程同时进入第一个if判断，那么他们也必须按照顺序执行synchronized块中的代码，第一个进入代码块的线程会创建一个新的Singleton实例，而后续的线程则因为无法通过if判断，而不会创建多余的实例。

但实际上，从JVM的角度讲，这些代码仍然可能发生错误：

对于JVM而言，它执行的是一个个java指令。在Java指令中创建对象和赋值操作时分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就是出错成为了可能，例如：

A、B线程同时进入第一个if判断
A首先进入synchronized块，由于instance为null,所以它执行instance = new Singleton();
由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员(此时JVM没有开始初始化这个实例)，然后A离开了synchronized块；
B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序；
此时B线程打算使用Singleton实例，却发现它没有被初始化，优势错误发生了；

3. 通过内部类实现多线程环境中的单件模式

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

JVM的内部机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕。此外该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低效问题。最后instance是在第一次加载SingletonContainer类时被创建的，而SingletonContainer类则在调用getInstance方法的时候才会被加载，因此也实现了惰性加载。