JAVA 设计模式之单例模式

单例模式的定义就是确保某一个类仅有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式分为：懒汉式单例、饿汉式单例、登记式单例三种。

单例模式特点如下：

1)单例类只能有一个实例。

2)单例类必须自己创建自己的唯一实例。

3)单例类必须给所有其他对象提供这一实例。

单例模式的优点是内存中只有一个对象，节省内存空间；避免频繁的创建销毁对象，可以提高性能；避免对资源的多重占用，简化访问；为整个系统提供一个全局访问点。

单例模式的缺点是不适用于变化频繁的对象；滥用单利将带来一些问题，如为了节省资源将数据库连接池对象设计为的单利类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失。

从名字上来说饿汉和懒汉，饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候单例是已经被初始化，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

1、懒汉式单例，具体代码如下：

package com.yoodb;
//懒汉式单例类.在第一次调用的时候实例化自己
public class Singleton {
	//私有的无参构造方法
	private Singleton(){
		
	}
	//注意，这里没有final
	private static Singleton single = null;
	//静态工厂方法
	public synchronized  static Singleton getInstance(){
		if(single == null){
			single = new Singleton();
		}
		return single;
	}
}

什么是线程安全？

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

2、饿汉式单例，具体代码如下：

package com.yoodb;

public class Singleton {
	//私有的无参构造方法
	private Singleton(){
		
	}
	//自动实例化
	private final static Singleton single = new Singleton();
	//静态工厂方法
	public static synchronized Singleton getInstance(){
		return single;
	}
}

3、登记式单例，具体代码如下：

package com.yoodb;

import java.util.HashMap;
import java.util.Map;

public class Singleton {
	public static Map<String,Singleton> map = new HashMap<String,Singleton>();
	static{
		//将类名注入下次直接获取
		Singleton single = new Singleton();
		map.put(single.getClass().getName(),single);
	}
	//保护式无参构造方法
	protected Singleton(){}
	
	public static Singleton getInstance(String name){
		if(name == null){
			name = Singleton.class.getName(); 
		}
		if(map.get(name) == null){
			try {
				map.put(name, Singleton.class.newInstance());
			} catch (InstantiationException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return map.get(name);
	}
	
    public String create() {      
return "创建一个单例！";      
    }  
	
	public static void main(String[] args) {
		 Singleton single = Singleton.getInstance(null);  
	     System.out.println(single.create());  
	}
}

饿汉式和懒汉式区别如下：

1、线程安全：

饿汉式是线程安全的，可以直接用于多线程而不会出现问题，懒汉式就不行，它是线程不安全的，如果用于多线程可能会被实例化多次，失去单例的作用。

2、资源加载：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，会占据一定的内存，相应的在调用时速度也会更快，而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次掉用时要初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

应用场景

1）需要生成唯一序列的环境；

2）需要频繁实例化然后销毁代码的对象；

3）有状态的工具类对象；

4）频繁访问数据库或文件的对象。

举例：windows的任务管理器，项目中的读取配置文件的对象，数据库连接池，spring中的bean默认也是单例，线程池（threadpool），缓存（cache），对话框，处理偏好设置和注册表（registry）的对象，日志对象，充当打印机，显卡等设备的驱动程序的对象。

注意：这类对象只能有一个实例，如果制造出多个实例，就会导致许多问题产生，例如：程序的行为异常，资源使用过量，或者是不一致的结果。