单例模式:顾名思意就是在一个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;
}
}