Java设计模式之《单例模式》及应用场景

所谓单例，指的就是单实例，有且仅有一个类实例，这个单例不应该由人来控制，而应该由代码来限制，强制单例。

一、常见的单例模式有两种创建方式：所谓懒汉式与饿汉式

（1）懒汉式
       何为懒？顾名思义，就是不做事，这里也是同义，懒汉式就是不在系统加载时就创建类的单例，而是在第一次使用实例的时候再创建。代码如下：

class LHanSingleCase{
	//定义一个私有变量来存放单例，私有的目的是指外部无法直接获取这个变量，而要使用提供的私有方法来获取
	private static LHanSingleCase singleCase = null;
	
	//定义私有构造器，表示只在类内部使用，亦指单例的实例只能在单例类内部创建
	private LHanSingleCase(){}
	
	//定义一个公共的公开的方法来返回该类的实例，由于是懒汉式，需要在第一次使用时生成实例，所以为了线程安全，使用synchronized关键字来确保只会生成单例
	public static synchronized LHanSingleCase getInstance(){
		if(singleCase == null){
			singleCase = new LHanSingleCase();
		}
		return singleCase;
	}
}

（2）饿汉式
       又何为饿？饿者，饥不择食；但凡有食，必急食之。此处同义：在加载类的时候就会创建类的单例，并保存在类中。代码如下：

class EHanSingleCase{
	//此处定义类变量实例直接实例化，在类加载的时候就完成了实例化并保存在类中
	private static EHanSingleCase singleCase = new EHanSingleCase();
	//定义无参数构造器，用于单例实例
	private EHanSingleCase(){}
	//定义公开方法，返回已创建的单例
	public static EHanSingleCase getInstance(){
		return singleCase; 
	}
}

二、双重加锁机制

何为双重加锁机制？
　    在懒汉式实现单例模式的代码中，有使用synchronized关键字来同步获取实例，保证单例的唯一性，
        但是上面的代码在每一次执行时都要进行同步和判断，无疑会拖慢速度，使用双重加锁机制正好可以解决这个问题：

        代码如下：

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

     双重加锁难道不是需要两个synchronized进行加锁的吗？
     其实不然，这里的双重指的的双重判断，而加锁单指那个synchronized，为什么要进行双重判断，其实很简单，第一重判断，如果单例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例;如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有两个调用同时进行时，导致生成多个实例，有了同步块，每次只能有一个线程调用能访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。至于第二个重空判断的作用，当多个线程一起到达锁位置时，进行锁竞争，其中一个线程获取锁，如果是第一次进入则dl为null，会进行单例对象的创建，完成后释放锁，其他线程获取锁后就会被空判断拦截，直接返回已创建的单例对象。
     不论如何，使用了双重加锁机制后，程序的执行速度有了显著提升，不必每次都同步加锁。

三、类级内部类方式

 *     饿汉式会占用较多的空间，因为其在类加载时就会完成实例化；
 *     而懒汉式又存在执行速率慢的情况；
 *     双重加锁机制呢？又有执行效率差的毛病；
       有没有一种完美的方式可以规避这些毛病呢？

　　貌似有的，就是使用类级内部类结合多线程默认同步锁，同时实现延迟加载和线程安全。

class ClassInnerClassSingleCase{
	public static class SingleCaseHolder{
		private static ClassInnerClassSingleCase singleCase = new ClassInnerClassSingleCase();
	}
	private ClassInnerClassSingleCase(){}
	public static ClassInnerClassSingleCase getInstance(){
		return SingleCaseHolder.singleCase;
	}
}

       所谓类级内部类，就是静态内部类，这种内部类与其外部类之间并没有从属关系，加载外部类的时候，并不会同时加载其静态内部类，只有在发生调用的时候才会进行加载，加载的时候就会创建单例实例并返回，有效实现了懒加载（延迟加载），至于同步问题，我们采用和饿汉式同样的静态初始化器的方式，借助JVM来实现线程安全。

       其实使用静态初始化器的方式会在类加载时创建类的实例，但是我们将实例的创建显式放置在静态内部类中，它会导致在外部类加载时不进行实例创建，这样就能实现我们的双重目的：延迟加载和线程安全。

四、使用场景

1、任务管理器就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows
 task manager吗？
2、（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
3、网站的计数器，一般也是采用单例模式实现，否则难以同步。
4、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
5、多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。