单例模式中懒汉模式的非线程安全问题的解决方法

非原创，转自https://blog.csdn.net/noaman_wgs/article/details/53258710

单例模式中懒汉模式的非线程安全问题的解决方法

   单例模式中有饿汉模式和懒汉模式两种。饿汉模式也叫立即加载 ，即在get之前就已经创建实例instance;

package singleton1;







//饿汉模式(立即加载)




public class Singleton {







	private static Singleton instance = new Singleton();







	private Singleton(){}







	public static Singleton getInstance(){



		return instance;



	}



}

而懒汉模式也叫延迟加载，即在get时才会被创建实例。懒汉模式在多线程的环境中就会出现多实例的情况，与单例模式相背离。如下代码可证：

package singleton2;



//懒汉模式




public class Singleton {







	private static Singleton instance = null;







	private Singleton(){}







	public static Singleton getInstance(){



		try {



			if(instance==null){



				Thread.sleep(1000);//模拟延迟加载




				instance=new Singleton();



			}



		} catch (InterruptedException e) {



			e.printStackTrace();



		}



		return instance;



	}



}

创建线程：

package singleton2;








public class ThreadA extends Thread{







	@Override




	public void run(){



		System.out.println(Singleton.getInstance().hashCode());//根据实例对象哈希值是否相同来判断对象是否相同




	}







}

创建运行类：

package singleton2;








public class Run {







	public static void main(String[] args) {



		ThreadA t1=new ThreadA();



		ThreadA t2=new ThreadA();



		ThreadA t3=new ThreadA();



		t1.start();



		t2.start();



		t3.start();



	}







}

运行结果：

1321522194



2134502363



866891806

哈希值不同，所以对象不同，即不是单例模式。如何解决这个问题呢，下面提供了几种方法：

一、方法上声明synchronized关键字(效率低)

package singleton2;



//懒汉模式




public class Singleton {







	private static Singleton instance = null;







	private Singleton(){}



	//1 方法上声明synchronized关键字




	synchronized public static Singleton getInstance(){



		try {



			if(instance==null){



				Thread.sleep(1000);//模拟延迟加载




				instance=new Singleton();



			}



		} catch (InterruptedException e) {



			e.printStackTrace();



		}



		return instance;



	}



}

运行结果如下：

1876189785



1876189785



1876189785

哈希值相同，是单例模式的实现。但这种加了synchronized关键字后，多线程进行操作时只能等一个线程处理完，下一个线程才能进入同步方法中，效率低下。

二、同步代码块(效率低)

package singleton3;



//懒汉模式




public class Singleton {







	private static Singleton instance = null;







	private Singleton(){}







	public static Singleton getInstance(){



		try {



			// 2 使用同步代码块，但效率低




			synchronized(Singleton.class){



				if(instance==null){



					Thread.sleep(1000);//模拟延迟加载




					instance=new Singleton();



				}



			}



		} catch (InterruptedException e) {



			e.printStackTrace();



		}



		return instance;



	}



}

运行结果：

1619327594



1619327594



1619327594

       使用同步代码块方式也能解决上述问题，虽然不需要判断实例是否为null,但同样的也会带来效率低的毛病。

三、使用DCL(Double-Check Locking)双检查锁机制---（推荐）

public class Singleton {



	private static volatile Singleton instance = null;



	private Singleton(){}







	public static Singleton getInstance(){



		if(instance == null){



			synchronized(Singleton.class){



				if(instance == null){



					instance = new Singleton();



				}



			}



		}



		return instance;



	}



}

这里为什么要用volatile修饰instance？

原因：在于instance = new Singleton()的时候，在内存中实际上是分3步执行的：

1）分配对象的内存空间：memory = allocate();

2）初始化对象：ctorInstance(memory);

3）指向分配的地址：instance =memory

多线程在执行的时候，2 3可能发生重排序。即有可能线程A执行到第3步的时候，读取到instance不为null，就返回。实际上此时还未执行第二部即未初始化。

加上volatile就可以避免2 3步重排序来保证线程安全。

四、使用静态内部类来实现单例模式

package singleton6staticinnerclass;








public class Singleton {







	//静态内部类进行初始化




	private static class SingletonHandler{



		private static Singleton instance = new Singleton();



	}







	private Singleton(){}







	public static Singleton getInstance(){



		return SingletonHandler.instance;



	}



}

五、static代码块来实现单例模式

package singleton7static;








public class Singleton {







	private static Singleton instance = null;







	private Singleton(){}



	//静态代码块




	static{



		instance=new Singleton();



	}



	public static Singleton getInstance(){



		return instance;



	}



}

还有序列化和反序列化的单例模式来实现，或者使用枚举类来实现，在此就不一一介绍了，有兴趣可以百度下。