单例模式(Singleton Pattern)

1.概述：

单件模式（Singleton Pattern）：用来创建独一无二的，只能有一个实例的对象的入场券。有一些对象，我们只需要一个，例如：线程池、缓存、对话框等等。这些类对象只能有一个实例，如果制造出多个实例，就会导致许多问题产生。

经典的单件模式的实现方式：

构造方法是private，设定一个静态方法返回对象实例，类中一个静态变量存储一个该类变量（用来确定是否实例化过）。如下是实现代码：

package net.pmpa.singleton;

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println("s1 : "+s1+"\ns2 : "+s2);
	}

}

2.模式定义：

单件模式：确保一个类只有一个实例，并提供一个全局访问点。

关于全局访问点的解释：当你需要实例时，向类查询，它会返回单个实例。

单件模式的类图（比较简单，只有一个类）：

 

3.多线程思考：

 如果方法，public static Singleton getInstance() 允许多线程访问，可能会出现问题，可能会创建该类的2个不同的对象。为了防止这种情况，可以在这个方法前添加关键字synchronized，方法变为如下情况：

 public static synchronized Singleton getInstance(){
  if (sign == null)
  {
   sign = new Singleton();
  }
  return sign;
 }

通过增加synchronized关键字到getInstance()方法中，迫使每个线程在进入这个方法前，要先等候别的线程离开该方法。也就是说，不会有2个线程可以同时进入这个方法。

但是这种方法也有缺陷：会降低性能，只有第一次执行该方法时，才真正需要同步。解决方案如下：

（1）如果getInstance()的性能对应用程序不关键，就直接使用synchronized，不用其他的处理。

如果getInstance()比较复杂，而且会经常调用，使用synchronized会使程序性能降低100倍，就不能使用这种方法，否则就用synchronized。

package net.pmpa.singleton;

public class SingletonSynchronized {

	private static SingletonSynchronized sign;
	private SingletonSynchronized()
	{
		
	}
	
	public static synchronized SingletonSynchronized getInstance(){
		if (sign == null)
		{
			sign = new SingletonSynchronized();
		}
		return sign;
	}
}

 

（2）使用“急切”创建实例，而不用延迟实例化的做法：

如果应用程序总是创建并使用单件实例，或者在创建和运行时方面的负担不太繁重，可能想哟急切创建单件：

<p>package net.pmpa.singleton;</p><p>public class SingletonEagerly {
 
 private static SingletonEagerly sign = new SingletonEagerly();
 private SingletonEagerly()
 {
  
 }
 
 public static SingletonEagerly getInstance(){
  return sign;
 }</p><p>}
</p>

JVM保证在任何线程访问sign静态变量之前，一定先创建此实例，所以说代码“private static SingletonEagerly sign = new SingletonEagerly();”是线程安全的。

（3）用“双重检查加锁”，在getInstance()中减少使用同步：

首先检查是否实例已经创建了，如果尚未创建，才进行同步。这样保证了只有第一次才会同步。

public class SingletonDoublecheck {
	private volatile static SingletonDoublecheck sign;
	private SingletonDoublecheck()
	{
		
	}
	public static SingletonDoublecheck getInstance(){
		if(sign == null){      //只有第一次彻底执行该代码
			synchronized (SingletonDoublecheck.class){   //进入区块后，再检查一次。如果sign仍是null才创建
				if (sign == null)
				{
					sign = new SingletonDoublecheck();
				}
			}
		}
		return sign;
	}
}

volatile：当sign变量被初始化为SingletonDoublecheck实例时，多个线程正确地处理sign变量。