Java中单例模式是一种常见的设计模式，单例模式分为：饿汉式单例模式、懒汉式单例模式、登记式单例模式、枚举式单例模式。作为对象的常见模式的单例模式，确保某一类只有一个实例，而且自行实例化并向整个系统提供这个实例。
       单例模式的特点：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

       举例说明：在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
【转载使用，请注明出处：http://blog.csdn.net/mahoking】

饿汉式单例模式用例：

/**
 * 饿汉式单例类
 * @author Mahc
 *
 */
public class EagerSingleton {

	private static EagerSingleton instance = new EagerSingleton();
	
	/**
	 * 私有的构造方法/构造函数
	 */
	private EagerSingleton(){}
	
	/**
	 * 静态工厂方法
	 * @return instance
	 */
	public static EagerSingleton getInstance(){
		
		return instance;
	}
}

         饿汉式是典型的空间换时间，当类装载的时候就会创建类的实例，在未使用时，就已经创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。
 懒汉式单例模式用例：

/**
 * 懒汉式单例类
 * @author Mahc
 *
 */
public class LazySingleton {

	private static LazySingleton instance = null;
	
	/**
	 * 私有的构造方法/构造函数
	 */
	private LazySingleton(){}
	
	/**
	 * 静态工厂方法
	 * 由于懒汉式的实现是线程安全的 ,所以使用了   synchronized
	 * @return instance
	 */
	public synchronized static LazySingleton getInstance() {
		if(instance == null){
			instance = new LazySingleton();
		}
		return instance;
	}
	
}

        懒汉式是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。
       由于懒汉式的实现是线程安全的，这样会降低整个访问的速度，而且每次都要判断,所以需要更好的实现方式。
登记式单例模式用例：

/**
 * 登记式单例类
 * 类似Spring里面的方法，将类名注册，下次从里面直接获取。 
 * @author Mahc
 * 
 */
public class RegisterSingleton {

	private static Map<String, RegisterSingleton> map = new HashMap<String, RegisterSingleton>();
	static{
		RegisterSingleton singleton = new RegisterSingleton();
		map.put(singleton.getClass().getName(), singleton);
	}
	
	protected RegisterSingleton(){}
	
	/**
	 * 静态工厂方法,返还此类惟一的实例  
	 * @param name
	 * @return
	 */
	public static RegisterSingleton getInstence(String name){
		
		if(name == null){
			name = RegisterSingleton.class.getName();
		}
		if(map.get(name) == null){
			try {
				map.put(name, (RegisterSingleton)Class.forName(name).newInstance());
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		return map.get(name);
	}
	
}

           登记式单例模式，使用Class加载器，辅助Map对象将Singleton的name作为key值保存Value(Singleton的实例对象)。
本例使用枚举的关键字 enum 枚举式单例模式用例：

public enum EnumSingleton {

	/**
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。
     * @author Mahc
	 */
	uniqueInstance;
	
}

测试各种样式的单例模式测试类：

public class TestSingleton {

	public static void main(String[] args) {
		
		//测试饿汉式模式
		EagerSingleton eagerSingleton01 = EagerSingleton.getInstance();
		EagerSingleton eagerSingleton02 = EagerSingleton.getInstance();
		if(eagerSingleton01 == eagerSingleton02){
			System.out.println("EagerSingleton\n" + true);
		}
		
		//测试懒汉式模式
		LazySingleton lazySingleton01 = LazySingleton.getInstance();
		LazySingleton lazySingleton02 = LazySingleton.getInstance();
		if(lazySingleton01 == lazySingleton02){
			System.out.println("LazySingleton\n" + true);
		}
		
		//测试登记式模式
		RegisterSingleton registerSingleton01 = RegisterSingleton.getInstence(null);
		RegisterSingleton registerSingleton02 = RegisterSingleton.getInstence(null);
		if(registerSingleton01 == registerSingleton02){
			System.out.println("RegisterSingleton\n" + true);
		}
		
		//枚举式模式
		EnumSingleton enumSingleton01 = EnumSingleton.uniqueInstance;
		EnumSingleton enumSingleton02 = EnumSingleton.uniqueInstance;
		if(enumSingleton01 == enumSingleton02){
			System.out.println("EnumSingleton\n" + true);
		}
	}
	
}

【转载使用，请注明出处：http://blog.csdn.net/mahoking】

设计模式【单例模式】