单例模式

单例模式：顾名思意就是在一个JAVA程序中某一个类只能存在一个实列。

 

1：饿汉式

public class EagerSingleton {
        //实例创建
	private static EagerSingleton instance=new EagerSingleton();
	//私有构造方法
	private EagerSingleton(){}
	
	public static EagerSingleton getInstance(){
		return instance;
	}
}

 2：懒汉式

public class LazySingleton {

	private static LazySingleton instance=null;
	//私有构造方法
	private LazySingleton(){}
	/**
	 * 公共方法提供唯一实例
	 * 这里加同步快会有性能的问题。因为每次取得当这个instance都会先同步，会多少产生性能的损耗。
	 * @return
	 */
	public static synchronized LazySingleton getInstance(){
		if(instance==null){
			instance=new LazySingleton();
		}
		return instance;
	}
}

 3：懒汉式-改进版

/**
 * 单例模式--懒汉改进版（双重检查加锁）
 * 
 * 但这个方法也还是不能完美的解决单例即延时加载、线程安全且高效的问题。怎么解决？ 看LazySingleton_improve2
 *
 */
public class LazySingleton_improve {

	/**
	 * “双重检查加锁”机制的实现会使用关键字volatile，它的意思是：被volatile修饰的变量的值，
	 * 将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。
	 * 注：volatile只适应JDK1.5以上包含1.5，且volatile的性能不高效，不见意使用。
	 */
	private volatile static LazySingleton_improve instance=null;
	
	private LazySingleton_improve(){}
	
	/**
	 * 在取当前instance时先不进行同步操作，而是在判断当前instance不在的情况下,增加同步块来保证instance的创建。
	 * 这样有效避免每次都进行同步操作。
	 * @return
	 */
	public static LazySingleton_improve getInstance(){
		if(instance==null){
			synchronized(LazySingleton_improve.class){
				if(instance==null){
					instance=new LazySingleton_improve();
				}
			}
		}
		return instance;
	}
}

 4：懒汉式-完美版

/**
 * 单例模式--懒汉完美版（完美的解决了线程安全，效率，延迟加载等问题）
 *
 */
public class LazySingleton_improve2 {

	/**
	 * 私有构造器
	 */
	private LazySingleton_improve2(){};
	
	/**
	 * 静态内部类。
	 *
	 */
	private static class SingletonHolder{
		private static LazySingleton_improve2 instance=new LazySingleton_improve2();
	}
	
	/**
	 * 当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，
	 * 导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，
	 * 从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，
	 * 并由虚拟机来保证它的线程安全性。
	 * @return
	 */
	public static LazySingleton_improve2 getInstance(){
		return SingletonHolder.instance;
	}
}