java线程安全的单例模式（转载）

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

      public final class EagerSingleton
      {
      private static EagerSingleton singObj = new EagerSingleton();
      private EagerSingleton(){
       }
      public static EagerSingleton getSingleInstance(){
      return singObj；
       }
      }
  
 

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

这种写法就是所谓的懒汉模式。它使用了延迟加载来保证对象在没有使用之前，是不会进行初始化的。但是，通常这个时候面试官又会提问新的问题来刁难一下。他会问：这种写法线程安全吗？回答必然是：不安全。这是因为在多个线程可能同时运行到第九行，判断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；
       }
      }
  
 

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

      public class Singleton
      {
      private static class SingletonHolder
       {
      public final static Singleton instance = new Singleton();
       }
      public static Singleton getInstance()
       {
      return SingletonHolder.instance;
       }
      }
  
 

文章来源: bugstack.blog.csdn.net，作者：Yao__Shun__Yu，版权归原作者所有，如需转载，请联系作者。

原文链接：bugstack.blog.csdn.net/article/details/8142463