单例模式及具体实现

单例模式

一 ：核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

二：常见应用场景

——Windows的任务管理器就是很典型的单例模式
——windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
——项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
——网站的计数器，一般也是采用单例模式实现，否则难以同步。
—— 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
——在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理
——在servlet编程中，每个Servlet也是单例 – 在spring MVC框架/struts1框架中，控制器对象也是单例

三：单例模式的优点

由于单例模式只生成一个实例，减少了系统性能开销。
当一个对象的产生需要较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
单例模式可以在系统设置全局的访问点，优化环共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

四：单列模式的五种实现方式

主要

1：饿汉式（线程安全，调用效率高。但是不能延迟加载）
2：懒汉式（线程安全，调用效率不高。但是可以延迟加载）

其他：

1：双重检测锁（可能会和底层JVM冲突，一般；不推荐使用）
2：静态内部类（线程安全，调用效率高。可以延迟加载）
3：枚举单例（线程安全，调用效率高。可以延迟加载）

如何选择?：

– 单例对象  占用  资源 少，不需要  延时加载：

• 枚举式 好于 饿汉式
– 单例对象 占用 资源 大，需要 延时加载：
• 静态内部类式 好于 懒汉式

五：代码实现

(出枚举外，前四种方式可能通过反射和反序列化的方式破解，
解决方法：解决反射——构造器中加个判断 不为null则手动抛出异常
解决序列化——定义一个方法 调用时返回原来的值而不是新实例化一个对象)

1：饿汉式

饿汉式单例模式代码中，static变量会在类装载时初始化，

• 此时也不会涉及多个线程对象访问该对象的问 题。虚拟机保证只会装载一次该类，
• 肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。
• 问题：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

package singlePattern;
/**
* @author 作者 :北城
*目的：  1:饿汉式的实现
*	单例对象立即加载
*/

public class Demo01 {
	//类初始化时立即加载这个对象（没有延时加载的优势,线程安全
	private static  Demo01 instance=new Demo01();
	private Demo01() {}//私有化构造器
	
	//方法没有同步，调用效率高！
	public static Demo01 getInstance() {
		return instance;
		
	}

}

2：懒汉式

package singlePattern;
/**
* @author 作者 :北城
*目的：  1:懒汉式的实现
*    单例对象延迟实现
*
*/

public class Demo02 {
	//类初始化时先不加载对象
	private static  Demo02 instance;
	private Demo02() {}//私有化构造器
	
	//方法同步，调用效率低！
	public static synchronized Demo02 getInstance() {
		if(instance==null) {
		instance=new Demo02();
		}
		return instance;
		
	}

}

3：双重检测锁

package singlePattern;
/**
* @author 作者 :北城
*目的：  1:双重检测锁的实现
*
*/

public class Demo03 {

	  private static Demo03 instance = null; 

	  public static Demo03 getInstance() { 
	    if (instance == null) { 
	    	Demo03 sc; 
	      synchronized (Demo03.class) { 
	        sc = instance; 
	        if (sc == null) { 
	          synchronized (Demo03.class) { 
	            if(sc == null) { 
	              sc = new Demo03(); 
	            } 
	          } 
	          instance = sc; 
	        } 
	      } 
	    } 
	    return instance; 
	  } 

	  private Demo03() { 

	  } 
	
}

4：静态内部类

静态内部类也是懒汉式

• – 只有真正调用getInstance(),才会加载静态内部类。
• 加载类时是线程 安全的。
• instance是static final 类型，保证了内存中只有这样一个实例存在，

•   而且只能被赋值一次，从而保证了线程安全性. 
  

• – 兼备了并发高效调用和延迟加载的优势！

package singlePattern;
/**
* @author 作者 :北城
*目的：  1:静态内部类的实现

*
*/

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

5：枚举单例

•   	枚举本身就是单例模式。
  

•   	由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！ 
  

• 缺点： 无延迟加载

package singlePattern;
/**
* @author 作者 :北城
*目的：  1:枚举式的实现
* 优点：  实现简单

*/

public enum Demo05 {
	//这个枚举元素，本身就是单例对象！
		INSTANCE;
		
		//添加自己需要的操作！
		public void singletonOperation(){
		}
}

6：测试

package singlePattern;
/**
* @author 作者 :北城
*
*/

public class Client {
	public static void main(String[] args) {
		//饿汉式
		Demo01 d=Demo01.getInstance();
		Demo01 d2=Demo01.getInstance();//结果应该是一样的
		System.out.println(d);
		System.out.println(d2);
		//懒汉式
		Demo02 d3=Demo02.getInstance();
		Demo02 d4=Demo02.getInstance();
		System.out.println(d3);
		System.out.println(d4);
		//静态类
		Demo04 d5=Demo04.getInstance();
		Demo04 d6=Demo04.getInstance();
		System.out.println(d5);
		System.out.println(d6);
		//枚举
		System.out.println(Demo05.INSTANCE==Demo05.INSTANCE);//（此处稍微有点小问题）
	}

}

结果如图