Java懒汉式单例模式详解

标签：

    单例模式最常见的有两种，饿汉式和懒汉式两种。本文先简单说一下懒汉式单例，再着重叙述饿汉式单例，饿汉式单例是本文的叙述重点。

    懒汉式的优点是：写起来比较简单，而且不存在多线程同步问题，避免了synchronized所造成的性能问题；缺点是：初始化类的时候就需要构造实例，（即便你还没有用到这个实例），因此在某些特定条件下会耗费内存。懒汉式的写法如下：

 1 /**
 2  * 懒汉式单例
 3  * @author James Chong
 4  *
 5  */
 6 public class SingleTon {
 7     
 8     //加载类的时候会初始化static的instance，从这以后，这个static的instance对象便一直占着这段内存，永远不会被回收掉。
 9     private static SingleTon instance = new SingleTon();
10     
11     private SingleTon(){//将构造函数private掉，避免直接new SingleTon()
12         super();
13     }
14     
15     /**
16      * 因为是单例，所以只能通过static方法来获取实例，因此必须是static的。
17      * 方法实现较为简单，因为instance已经在加载类的时候被初始化好了，所以不存在多线程并发造成的问题
18      */
19     public static SingleTon getInstance(){
20         return instance;
21     }
22 }

饿汉式的优点是：只有第一次用到的时候才进行初始化，故在还没用到的时候，会省内存； 缺点是：需要用synchronized关键字进行锁的控制，性能会差一些，代码写起来麻烦些。饿汉式的实现代码如下：

 1 /* 饿汉式单例
 2  * @author James Chong
 3  */
 4 public class SingleTon {
 5     
 6     private static volatile SingleTon instance;//volitile稍后会解释
 7     public String url;
 8     
 9     private SingleTon(){
10         super();
11         url = "http://www.laomiaopu.com";
12     }
13     
14     public static SingleTon getInstance(){
15         if(null == instance){
16             synchronized(SingleTon.class){//稍后会解释为什么synchronized要这么用，并且需要判断两次null == instance
17                 if(null == instance){
18                     instance = new SingleTon();
19                 }
20             }
21         }
22         return instance;
23     }
24     
25     public static synchronized void f1(){
26         System.out.println("吉姆斯是个大帅哥！");
27         System.out.println("http://www.laomiaopu.com");
28     }
29 }

1. 一般用synchronized修饰第14行的getInstance()方法就可以了，干嘛要把synchronized块写到函数体里呢？

    原因如下：假设SingleTon这个类还有个synchronized的static函数f1()，那么，一旦调用f1()正在进行的时候，SingleTon的class对象会被锁住，故而getInstance()方法就要等待了。同理，一旦调用getInstance()正在进行的时候，f1()就无法被调用，只能等待getInstance()执行完了才能执行。所以把synchronized写到函数里面，实际上是减小了锁的粒度。这样当instance已经被实例化了的时候，getInstance()这个函数是不会加锁的，故不影响f1()函数的调用。

2. 为啥要判断两次null == instance呢？把第15行的外层if判断去掉不行吗？

    行！去掉也不会出错，但是如果判断两次性能更好。因为如果只判断一次的话，每次执行getInstance()函数都要对synchronized块进行加锁；而如果进行两次判断的话，只有第一次调用的时候（即instance==null）的时候会对synchronized块进行加锁，其他时候（如果发现instance!=null）是不需要加锁的。

3.把第17行的内存if判断去掉不行吗？

　　不行！很有可能当外层判断的时候，instance确实是null；但是到了synchronized块中，执行第18行的instance = new SingleTon();的时候，instance已经被其他的线程给实例化了。

4. volatile是否有必要？

    如果只判断一次null==instance的话，就没必要了。但如果像本博客代码里写的那样，判断了两次null==instance，那么volatile是必要的。

    为什么呢？举个反例，假设线程thread1走到了第15行的if判断发现instance==null成立，于是都进入了外部的if体。这时候thread1先获取了synchronized块的锁，于是thread1线程会执行第18行的instance = new SingleTon();这句代码，问题就出在这里，这条语句它不是原子性执行的。在Java里，实例化一个对象的过程简单地讲，可以分为两步1）先为instance对象分配一块内存，2）在这块内存里为instance对象里的成员变量赋值（比如第11行里为url赋值）。假设当thread1执行完第1）步而还没有执行第2）步的时候，另外一个线程thread2走到了第15行，这时候instance已经不是null了，于是thread2直接返回了这个instance对象。有什么问题呢？instance对象的初始化（变量赋值等操作）还没执行完呢！thread2里直接得到了一个没有初始化完全的对象，就有可能导致很严重的问题了。

    那么volatile关键字有啥作用呢？当用volatile修饰了instance变量之后，对instance的写操作”先行发生“于对它的读操作。（这是Java虚拟机里的先行发生原则，不明白的网友可以留言或是看看Java虚拟机的相关资料。）这样就保证了，thread1中的instance变量被完全初始化之后，thread2才能读取它，当没有完成初始化时，thread2只能等会儿啦。

Java懒汉式单例模式详解

标签：

原文地址：http://www.cnblogs.com/james6176/p/3640144.html