1. class Single{
   
2.         private Single(){
   
3.                
   
4.         }
   
5.         private static Single single = null;
   
6.                
   
7.         public static Single getIntence(){
   
8.                 if(single==null){
   
9.                         //为什么加了双重的判断可以提高效率
   
10.                         synchronized (Single.class) {
    
11.                                 if(single==null){
    
12.                                         single = new Single();
    
13.                                 }
    
14.                         }        
    
15.                 }
    
16.                 return single;
    
17.         }
    
18. }

复制代码

//为什么加了双重的判断可以提高效率

这里视频里说得已经很清楚了，如果不用双重那么每次进去都要判断锁，所以就很慢
加了双重后，只要有一个线程完成了，后面想要进去的就在外面的if(single==null)这里判断就为假了，就进不去了，也就不用再进行锁的判断。  很明显判断锁肯定要比if(single==null)麻烦得多
所以能提高效率的原因是减少了锁的判断

这个引起效率问题的主要是synchronized引起的,因为每次进入同步代码块的时候,只允许一个线程进入,
其他的线程将都在等待那个进入同步代码块的线程执行完毕,再极端一点,如果已经在同步代码块的线程此时失去了CPU执行权,那么外面的线程将会等待更久,
而且不管单例对象是否已经实例化,都要每次进行等待,所以执行效率很低,
但是如果在同步代码块外面再加一个判断的话,如果判断到单例引用已经有对象的话,线程就不用走同步代码块里面的内容了,也就是说不用进行等待了,每个线程都可以进行判断,然后直接取得单例引用,而不用排队来取得引用.