多线程单例模式的应用

一、”两次判断法“（效率依然会有影响）

Java代码  

1. public class SingletonTest  
2. {  
3.     private static SingletonTest singletonTest = null;  
4.     private static Object syncObj = new Object();  
5.   
6.     private SingletonTest()  
7.     {  
8.     }  
9.   
10.     public static SingletonTest getInstance()  
11.     {  
12.   
13.         if (null == singletonTest)   //第一次判断  
14.         {  
15.   
16.             synchronized (syncObj)  
17.             {  
18.                 if (null == singletonTest)   //第二次判断  
19.                 {  
20.                     singletonTest = new SingletonTest();  
21.                 }  
22.             }  
23.   
24.         }  
25.   
26.         return singletonTest;  
27.     }  
28. }  

   结论：

  （1）这样会使得当第一次判断为false的时候，不进入同步块，使得效率比原方法高。

  （2）但是：两次判断，使得代码复杂易错，不是很推荐。

 

 

二、”静态成员变量法“

Java代码  

1. public class SingletonTest  
2. {  
3.         //在类里面实例化静态成员变量  
4.     private static SingletonTest singletonTest = new SingletonTest();  
5.   
6.     private SingletonTest()  
7.     {  
8.     }  
9.   
10.     public static SingletonTest getInstance()  
11.     {  
12.         return singletonTest;  
13.     }  
14. }  

   结论：

   （1）使用类的构造方法时初始化静态变量，创建唯一的静态实例。

   （2）简洁，效率高！（无锁）

   （3）但是：因为只要使用SingletonTest类，默认创建实例（不管需不需要这个实例）。这种默认创建实例，会导致内存使用效率的降低！

 

三、”按需创建“方法

Java代码  

1. public class SingletonTest  
2. {  
3.     private SingletonTest()  
4.     {  
5.     }  
6.   
7.     private static class Inner   //私有的静态内部类  
8.     {  
9.         static SingletonTest singletonTest = new SingletonTest();  
10.     }  
11.   
12.     public static SingletonTest getInstance()  
13.     {  
14.         return Inner.singletonTest;  
15.     }  
16. }  

   结论：

  （1）私有的静态内部类，当不调用getInstance()方法时，就不会调用这个内部类，就不会产生实例。

  （2）没有使用锁，没有产生无用的实例。确实是最好的方法。

附原文地址：http://770736680.iteye.com/blog/2036707