说说单例模式

      单例模式？多么简单！也许吧，可是要通过简单的现象，看到问题的本质，就比较难，知其然而不知其所以然，这种态度不好。

 

一：看看最简单的

public class SingleInstance{
  private static  instance=new SinleInstance();

  public static SingleInstance getInstance(){
   return instance;
  }
}

 

这个很明了，也确实会返回唯一的实例，但是如果我永远都不会用到SingleInstance.getInstance()，instance这个对象却一直存在，占用了内存空间，浪费。

 

二：那就不先实例化

public class SingleInstance{
  private static  SingleInstance instance;

  public static  SingleInstance getInstance(){
   if(instance==null){
      instance=new SingleInstance();
   }
   return instance;
  }
}

表面上，这个似乎是可行的。但是很显然，在多线程并发环境中，可能会创建两个instance，也有可能一个线程拿到的instance是一个不完整的实例。

 

三：好吧，那我加上同步总可以吧

public class SingleInstance{
  private static  SingleInstance instance;

  public static synchronized SingleInstance getInstance(){
   if(instance==null){
      instance=new SingleInstance();
   }
   return instance;
  }
}

这个虽然不会有内存上的浪费，但是有同步锁住了整个class，会降低系统的性能。按照数据结构的说法，就是一个提高了空间复杂度，一个提高了时间复杂度。

 

四：最佳实践

比较好的做法 

public class SingleInstance {
    private static class InstanceHolder {
        public static final SingleInstance instance = new SingleInstance();
    }

    public static SingleInstance getInstance() {
        return InstanceHolder.instance;
    }
}

这种Holder做法保证了实例在用到的时候才会创建，而且创建的实例肯定是唯一的。

五:所谓的DCL
下面这种做法是广为流传的所谓DCL（双重检查锁定）做法，这是没有正确理解java内存模型造成的，只保证了创建实例的原子性，而没有解决共享资源的可见性。

public class SingleInstance{
  private static  SingleInstance instance;

  public static  SingleInstance getInstance(){
   if(instance==null){
       synchronized(SingleInstance.class){
           if(instance==null){
               instance=new SingleInstance();
           }
       }
   }
   return instance;
  }
}

表面上看，这个似乎确实没有什么问题呢，其实还是有问题的，虽然概率比较小，要深刻的理解为什么，必须要对java内存模型比较熟悉。对于instance的创建，某个时刻某个线程拿到了同步锁，将instance创建了，并且及时写回了主存。但是对于另一个线程而言，它不能及时“看到”instance变量的最新值。它的instance可能是工作内存里的而不是主内存里的，甚至更为糟糕的情况是，instance是主内存的，可它的某些属性是工作内存的，这会导致程序发生莫名其妙不可捉摸的错误。在平台级框架里，这会造成系统在高并发环境下不稳定，甚至造成致命的错误 。

评论

10 楼 mengsina 2012-05-18  

楼主的意思是：？
1.线程A进入getInstance()方法；
2.线程B进入getInstance()方法；
3.线程A执行，if(instance==null)，从主存拷贝instance到工作内存；
4.线程B执行，if(instance==null)，从主存拷贝instance到工作内存；
5.线程A进入临界区：

synchronized(SingleInstance.class){   
           if(instance==null){   
               instance=new SingleInstance();   
           }   
       }

执行完后，线程A同步至主存，

接下来就是楼主担心的吗？

就是“该线程放弃锁后，后续执行的线程执行if(instance==null)时，instance不一定是主内中最新的”

可问题是，如果对SingleInstance.class加锁，上述步骤中的2,4会发生吗？即使在一个高度并发的情况下？

再问：

如果对SingleInstance.class加锁，线程A获取到了锁，那么线程B是不是就需要等待，即使高度并发？

如果线程B需要等待，那么线程A执行的就是原子性动作，等线程B去执行时，获取到的自然就是线程A同步好的instance，应该不会出现楼主担心的情况，不知道是不是这样？

我测试了一下，你说的是对的，不会出现楼主担心的情况。
但是，锁住的不是整个方法，所以上述步骤中的2 发生，即每次读的值 是工作内存的，可能是和其他线程修改后的值不一样，即旧值。  
步骤 4不会发生。每次 4 都是从主内存中拷贝一份新的。即其他线程修改后的新值。

9 楼 sunxian99 2012-02-01  

dcl 没有解决共享资源的可见性 那加上volatile 呢 这个实例就是在主内存中了

8 楼 huhu_long 2011-10-28  

trunk 写道

第一种怎么浪费啦。。。。不理解啊。你不调用SingleInstance.getInstance()，那么private static  instance=new SinleInstance()应该就不会被执行啊，那么就不会new SinleInstance()啊,难道在SingleInstance类加载的时候 就对静态的属性初始化了？ 可是类加载有好几种方式啊不一定加载的时候就对静态变量赋值...,楼主能否解析下疑问啊......

同意，这里如果你不去调用getInstance()的话应该是不会初始化的。 当 setstatic, putstatic, invokestatic等指令被调用的时候才会去初始化类。 所以如果不去调用getInstance()方法的话，instance将仍然维持零值NULL.

请主人confirm.

7 楼 regbin 2011-09-27  

DCL下
private static  SingleInstance instance;  

加volatile可以解决问题

6 楼 wupuyuan 2011-09-05  

我觉得恶汉模式就可以，毕竟产生出来空间不大，而且，如果生产出来不用的话是设计的问题！

5 楼 swinginginging 2011-09-01  

jameswxx 写道

ryuluck 写道

 if(instance==null){   
       synchronized(SingleInstance.class){   
           if(instance==null){   
               instance=new SingleInstance();   
           }   
       }   
   } 

临界区这里的instance，难道不是从主内存拷贝到工作内存里面的吗？

进入临界区这里的线程，instance是从主内存拷贝到工作内存。
该线程放弃锁后，后续执行的线程执行 if(instance==null)时，instance不一定是主内中最新的。

楼主的意思是：？
1.线程A进入getInstance()方法；
2.线程B进入getInstance()方法；
3.线程A执行，if(instance==null)，从主存拷贝instance到工作内存；
4.线程B执行，if(instance==null)，从主存拷贝instance到工作内存；
5.线程A进入临界区：

synchronized(SingleInstance.class){   
           if(instance==null){   
               instance=new SingleInstance();   
           }   
       }

执行完后，线程A同步至主存，

接下来就是楼主担心的吗？

就是“该线程放弃锁后，后续执行的线程执行if(instance==null)时，instance不一定是主内中最新的”

可问题是，如果对SingleInstance.class加锁，上述步骤中的2,4会发生吗？即使在一个高度并发的情况下？

再问：

如果对SingleInstance.class加锁，线程A获取到了锁，那么线程B是不是就需要等待，即使高度并发？

如果线程B需要等待，那么线程A执行的就是原子性动作，等线程B去执行时，获取到的自然就是线程A同步好的instance，应该不会出现楼主担心的情况，不知道是不是这样？

4 楼 zuozhengfeng 2011-07-21  

jameswxx 写道

ryuluck 写道

 if(instance==null){   
       synchronized(SingleInstance.class){   
           if(instance==null){   
               instance=new SingleInstance();   
           }   
       }   
   } 

临界区这里的instance，难道不是从主内存拷贝到工作内存里面的吗？

进入临界区这里的线程，instance是从主内存拷贝到工作内存。
该线程放弃锁后，后续执行的线程执行 if(instance==null)时，instance不一定是主内中最新的。

确实不太理解这段代码会出现什么样的问题，为什么会有这样的问题！作者有心的话可以写出一个浅显易懂的文章分享！

3 楼 trunk 2011-07-18  

第一种怎么浪费啦。。。。不理解啊。你不调用SingleInstance.getInstance()，那么private static  instance=new SinleInstance()应该就不会被执行啊，那么就不会new SinleInstance()啊,难道在SingleInstance类加载的时候 就对静态的属性初始化了？ 可是类加载有好几种方式啊不一定加载的时候就对静态变量赋值...,楼主能否解析下疑问啊......

2 楼 jameswxx 2011-05-24  

ryuluck 写道

 if(instance==null){   
       synchronized(SingleInstance.class){   
           if(instance==null){   
               instance=new SingleInstance();   
           }   
       }   
   } 

临界区这里的instance，难道不是从主内存拷贝到工作内存里面的吗？

进入临界区这里的线程，instance是从主内存拷贝到工作内存。
该线程放弃锁后，后续执行的线程执行 if(instance==null)时，instance不一定是主内中最新的。

1 楼 ryuluck 2011-05-24  

 if(instance==null){   
       synchronized(SingleInstance.class){   
           if(instance==null){   
               instance=new SingleInstance();   
           }   
       }   
   } 

临界区这里的instance，难道不是从主内存拷贝到工作内存里面的吗？