Java中几种单利模式实现

Java中单利模式有几种实现方式，存在差异。以此做记录便于之后查看

一：饿汉式单利模式

public class HungrySingleton{
    
    // 比较安全的方式
    private static final HungrySingleton instance = new HungrySingleton();
	private HungrySingleton(){
		
	}
	public static HungrySingleton getInstance(){
		return instance;
	}
}

二：懒汉式单利模式

/**
* 懒加载的话 如果多线程 可能存在创建多个instance实例
*/
public class LazySingleton {

	private static LazySingleton instance;
	private LazySingleton (){}
	
	public static LazySingleton getInstance(){
		if(instance ==null){
			instance = new LazySingleton ();
		}
		return LazySingleton .instance;
	}
}

三：加锁方式

/**
 * synchronized可以解决多线程情况下创建多个instance情况，
 * 但是影响性能，加锁使程序串行化
 * */
public class SynSingleton{

	private static SynSingleton instance;
	private SynSingleton(){}
	
	public synchronized static SynSingleton getInstance(){
		if(instance ==null){
			instance = new SynSingleton();
		}
		return SynSingleton.instance;
	}
}

四：双检测方式

/**
 * 双检测方式
 * 解决懒加载创建单利出现的问题，避免性能上的不足
 * 可能会引起空指针异常的隐患.构造函数中有其他属性未能得到及时初始化，Java重排序导致的空指针
 * */
public class DoubleCheckSingleton {

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

五：volatile + double check 方式

// DCV （Double Check Volatile） 
public class DCVSingleton {
	
	//volatile并不能保持原子性，但可以保证内存的可见性与有序性。多个线程可以看到同一个东西
	private static volatile DCVSingleton instance;
	private DCVSingleton (){}
	
	//double check add volatile 单利/性能好/懒加载
	public synchronized static DCVSingleton getInstance(){
		if(null == instance){
			synchronized ((DCVSingleton .class)) {
				if(instance ==null){
					instance = new DCVSingleton ();
				}
			}
		}
		return DCVSingleton .instance;
	}
}

六：Effactive Java 推荐单利模式，利用内部静态类持有的方式

//懒加载 效率 线程安全  单利可行 effactive java推荐方式
public class EffactiveSingleton {

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

七：枚举方式实现单利模式

public class EnumSingleton {

	private EnumSingleton (){}
	
	private enum singleton{
		INSTANCE;
		private final EnumSingleton instance;
		singleton(){
			instance = new EnumSingleton ();
		}
		
		public EnumSingleton getInstance(){
			return instance;
		}
	}
	
	public static EnumSingleton getInstance(){
		return singleton.INSTANCE.getInstance();
	}
	
}