设计模式--单例模式的5种写法

第一种，懒汉式

//1.单例模式--懒汉式
 class Singleton1{
         /* 类初始化的时候不加载这个对象，真正使用的时候再创建此对象，延时加载（懒加载 lazy load） */
	 private static  Singleton1 instance=null;
	 private Singleton1(){}
	 
         /* 保证线程安全，方法同步，效率低 */
	 public static synchronized Singleton1 getInstance(){
		 if(instance==null){
			 instance=new Singleton1();
		 }
		 return instance;
	 }
	 
	 public void whateverMethod(){
		 //TODO
	 }
 }

第二种，饿汉式

 

//2.单例模式--饿汉式
class Singleton2{
        /* 类初始化的时候就加载此对象，天然的线程安全，但是不是延时加载 */
	 private static Singleton2 instance=new Singleton2();
	 private Singleton2(){}
	 
        /* 不用同步，效率高 */
	 public static Singleton2 getInstance(){
		 return instance;
	 }
	 
	 public void whateverMethod(){
		 //TODO
	 }
 }

 

第三种，枚举（java1.5之后）

//3.单例模式--枚举
enum Singleton3{
        /* 此枚举对象即单例对象，线程安全，但不能延时加载，可以天然的防止反射和反序列化漏洞 */
	 INSTANCE;
	 
	 public void whateverMethod(){
		 //TODO
	 }
}

第四种，双重检查加锁

//4.单例模式--双重检查加锁
 class Singleton4{
        /* 使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。 */
	 private volatile static Singleton4 instance=null;
	 private Singleton4(){}
	 
	 public static Singleton4 getInstance(){
		 if(instance==null){
			 synchronized(Singleton4.class){
				 if(instance==null){
					 instance=new Singleton4();
				 }
			 }
		 }
		 return instance;
	 }
	 
	 public void whateverMethod(){
		 //TODO
	 }
 }

第五种，静态内部类

//5.单例模式--使用静态内部类
class Singleton5{

        /* 线程安全  不用同步效率高  可以延时加载  */
	private static class SingletonHolder{
		private static final Singleton5 INSTANCE=new Singleton5();
	}
	private Singleton5(){}
	
	public static Singleton5 getInstance(){
		return SingletonHolder.INSTANCE;
	}
	
	public void whateverMethod(){
		 //TODO
	 }
}