高性能单例模式

转载 http://blog.csdn.net/generalfu/article/details/8142463

面试的时候，常常会被问到这样一个问题：请您写出一个单例模式（Singleton Pattern）吧。好吧，写就写，这还不容易。顺手写一个：

public final class EagerSingleton     
{     
    private static EagerSingleton singObj = new EagerSingleton();     

    private EagerSingleton(){     
    }     

    public static EagerSingleton getSingleInstance(){     
       return singObj；   
    }     
}    

这种写法就是所谓的饥饿模式（Singleton Pattern），每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题：如果这个对象很大呢？没有使用这个对象之前，就把它加载到了内存中去是一种巨大的浪费。针对这种情况，我们可以对以上的代码进行改进，使用一种新的设计思想——延迟加载（Lazy-load Singleton）。

public final class LazySingleton     
{     
    private static LazySingleton singObj = null;     

    private LazySingleton(){     
    }     

    public static LazySingleton getSingleInstance(){     
        if(null == singObj ) singObj = new LazySingleton();   
          return singObj；   
    }     
}   

这种写法就是所谓的饥饿模式（Singleton Pattern）。它使用了延迟加载来保证对象在没有使用之前，是不会进行初始化的。但是，通常这个时候面试官又会提问新的问题来刁难一下。他会问：这种写法线程安全吗？回答必然是：不安全。这是因为在多个线程可能同时运行到第九行，判断singObj为null，于是同时进行了初始化。所以，这是面临的问题是如何使得这个代码线程安全？很简单，在那个方法前面加一个Synchronized就OK了。

public final class ThreadSafeSingleton     
{     
    private static ThreadSafeSingleton singObj = null;     

    private ThreadSafeSingleton(){     
    }     

    public static Synchronized ThreadSafeSingleton getSingleInstance(){     
        if(null == singObj ) singObj = new ThreadSafeSingleton();   
            return singObj；   
    }     
}     

写到这里，面试官可能仍然会狡猾的看了你一眼，继续刁难到：这个写法有没有什么性能问题呢？答案肯定是有的！同步的代价必然会一定程度的使程序的并发度降低（Singleton Pattern）。那么有没有什么方法，一方面是线程安全的，有可以有很高的并发度呢？我们观察到，线程不安全的原因其实是在初始化对象的时候，所以，可以想办法把同步的粒度降低，只在初始化对象的时候进行同步。这里有必要提出一种新的设计思想——双重检查锁（Double-Checked Lock）。

public final class DoubleCheckedSingleton     
{     
    private static DoubleCheckedSingletonsingObj = null;     

    private DoubleCheckedSingleton(){     
    }     

    public static DoubleCheckedSingleton getSingleInstance(){     
        if(null == singObj ) {   
              Synchronized(DoubleCheckedSingleton.class){   
                     if(null == singObj)   
                           singObj = new DoubleCheckedSingleton();   
              }   
         }   
       return singObj；   
    }     
}    

这种写法使得只有在加载新的对象进行同步，在加载完了之后，其他线程在第九行就可以判断跳过锁的的代价直接到第15行代码了。做到很好的并发度。