解决单例设计模式中懒汉式线程安全问题

-------Android培训、java培训、期待与您交流！ ----------

首先写个单例：

[java]  view plain copy

1. public class SingleDemo {  
2.     private static SingleDemo s = null;  
3.     private SingleDemo(){}  
4.     public static  SingleDemo getInstance(){  
5.         if(s == null){  
6.             s = new SingleDemo();  
7.         }  
8.         return s;  
9.     }  
10. }  

写个测试类：

[java]  view plain copy

1. public class ThreadDemo3 {  
2.       
3.     public static void main(String[] args) {  
4.         SingleDemo s1 = SingleDemo.getInstance();  
5.         SingleDemo s2 = SingleDemo.getInstance();  
6.         System.out.println(s2 == s2);  
7.     }  
8. }  

运行结果一直都是true,说明单线程下是没问题的，下面写个多线程来访问单例

[java]  view plain copy

1. public class ThreadTest implements Runnable {  
2.     //存放单例对象，使用Set是为了不存放重复元素  
3.     public Set<SingleDemo> singles = new HashSet<SingleDemo>();  
4.     @Override  
5.     public void run() {  
6.         //获取单例  
7.         SingleDemo s = SingleDemo.getInstance();  
8.         //添加单例  
9.         singles.add(s);  
10.     }  
11. }  

使用多线程并发访问单例：

[java]  view plain copy

1. public class ThreadDemo3 {  
2.       
3.     public static void main(String[] args) {  
4. //      SingleDemo s1 = SingleDemo.getInstance();  
5. //      SingleDemo s2 = SingleDemo.getInstance();  
6. //      System.out.println(s2 == s2);  
7.         ThreadTest t = new ThreadTest();  
8.         new Thread(t).start();  
9.         new Thread(t).start();  
10.         new Thread(t).start();  
11.         new Thread(t).start();  
12.         new Thread(t).start();  
13.         new Thread(t).start();  
14.         new Thread(t).start();  
15.         new Thread(t).start();  
16.         System.out.println(t.singles);  
17.     }  
18. }  

运行结果如下：

[com.persagy.thread.SingleDemo@1bc4459, com.persagy.thread.SingleDemo@150bd4d]

或

[com.persagy.thread.SingleDemo@12b6651]

说明有线程并发访问安全问题，获取的不一定都是同一个实例

如何解决线程安全问题呢？

当然使用同步锁机制了啊

下面改进单例：

[java]  view plain copy

1. public class SingleDemo {  
2.     private static SingleDemo s = null;  
3.     private SingleDemo(){}  
4.     public static synchronized SingleDemo getInstance(){  
5.         if(s == null){  
6.             s = new SingleDemo();  
7.         }  
8.         return s;  
9.     }  
10. }  

加入同步函数后线程安全问题解决了

运行多次都是获取同一个实例，不会出现2个实例的情况了

[com.persagy.thread.SingleDemo@12b6651]

但是在多线程并发访问的情况下，每个线程每次获取实例都要判断下锁，效率比较低，为了提高效率，我加入了双重判断的方法，解决了效率的问题

代码如下;

[java]  view plain copy

1. public class SingleDemo {  
2.     private static SingleDemo s = null;  
3.     private SingleDemo(){}  
4.     public static  SingleDemo getInstance(){  
5.         /*如果第一个线程获取到了单例的实例对象， 
6.          * 后面的线程再获取实例的时候不需要进入同步代码块中了*/  
7.         if(s == null){  
8.             //同步代码块用的锁是单例的字节码文件对象，且只能用这个锁  
9.             synchronized(SingleDemo.class){  
10.                 if(s == null){  
11.                     s = new SingleDemo();  
12.                 }  
13.             }  
14.         }  
15.         return s;  
16.     }  
17. }  

用这种方式解决了懒汉式的线程安全问题，也提高了效率，但是在实际开发中还是用饿汉式的比较多，毕竟这个代码比较多，比较繁琐。