单例设计模式为什么推荐使用饿汉式呢？我总觉得懒汉式比较好呢？求解其中原因。

懒汉式 一般都是面试考的。
     开发用饿汉式比较好。    饿汉式安全。 懒汉式不是很安全。
           核心原因就是懒汉式不安全！

懒汉式 一般都是面试考的。
     开发用饿汉式比较好。    饿汉式安全。 懒汉式不是很安全。
           核心原因就是懒汉式不安全！

而且如果懒汉式要想安全的话，需要加同步，但加上同步之后，效率会变低，为了解决效率变低的问题需要进行双重判断，最后代码就变成了下面那样，很麻烦的，所以还是用饿汉式好了

1. class DanLi{
   
2.         private DanLi(){}
   
3.         private static DanLi danLi;
   
4.         private static DanLi getInstance(){
   
5.                 if (danLi==null) {
   
6.                         synchronized (DanLi.class) {
   
7.                                 if (danLi==null) {
   
8.                                         danLi=new DanLi();
   
9.                                 }
   
10.                         }
    
11.                 }
    
12.                 return danLi;
    
13.         }
    
14. }

复制代码

1. 先写一个简单的懒汉式：
   
2. 
   
3. public class Singleton
   
4. {
   
5.         private static Singleton instance = null;
   
6.         private Singleton() {}
   
7. 
   
8.         public static synchronized Singleton getInstance()
   
9.         {
   
10.                 if(instance == null)
    
11.                 {
    
12.                         instance = new Singleton();
    
13.                 }
    
14.                 return instance;
    
15.         }
    
16. }
    
17. 
    
18. 显然在多线程下肯定是不安全的，故加上synchronized，这样做封锁的是整个对象，性能会降低，
    
19. 因为每次调用getInstance()时都要对对象上锁，事实上只要在第一次调用时会创建对象，以后就不用创建了。
    
20. 改进如下：
    
21. 
    
22. public class Singleton
    
23. {
    
24.         private static Singleton instance = null;
    
25.         private Singleton() {}
    
26. 
    
27.         public static Singleton getInstance()
    
28.         {
    
29.                 if(instance == null)
    
30.                 {
    
31.                         synchronized(this)
    
32.                         {
    
33.                                 if(instance == null)
    
34.                                 {
    
35.                                         instance = new Singleton();
    
36.                                 }
    
37.                         }
    
38.                 }
    
39.                 return instance;
    
40.         }
    
41. }
    
42. 
    
43. 似乎解决了之前的问题，性能得到提升，但是还是有问题，原因在于在JAVA指令中创建对象和赋值是分开操作的，
    
44. 也就是instance = new Singleton();语句是分开操作执行的，但是JVM并不保证这两个操作的顺序是先后执行的，
    
45. 它可能为新的Singleton实例分配空间，然后直接复制给instance成员
    
46. 然后再去初始化Singleton实例，假设有线程A和B
    
47. 1，A，B同时进入第一个if判断
    
48. 2，A首先进入synchronized模块，发现instance为null，开始执行instance = new Singleton();
    
49. 3，由于JVM的一些优化操作，JVM先划出了一些空白内存给Singleton的实例instance，但并未初始化instance，A便离开了synchronized模块
    
50. 4，B发现instance不为null便直接离开了
    
51. 5，B打算使用instance实例发现它没有初始化，编译器出错！！！
    
52. 因此最好使用饿汉式！！

复制代码

fei_xiong 发表于 2014-5-2 09:30
而且如果懒汉式要想安全的话，需要加同步，但加上同步之后，效率会变低，为了解决效率变低的问题需要进行 ...

谢谢。明白了。

两大原因：代码简单，线程安全

不要着急 你还没学到多线程吧?  学了多线程就有详细的介绍  但是这个单例设计模式的设计思想你还是要好好理解一下的！

延迟加载，启动的时候不会创建对象