设计模式(003) 单例模式[上] 单身懒汉

时间：2015-05-22 11:40:47 阅读：211 评论：0 收藏：0 [点我收藏+]

标签：设计模式面向对象敏捷开发单例模式懒汉式

设计模式(003) 单例模式[上] 单身懒汉

什么是单例模式（What）？

GOF：“保证一个类仅有一个实例，并且提供一个访问它的全局访问点”。

“嗯...，GOF通常一言九鼎，单例就是这样子的。” -- OO先生边思考边说。

YSJIAN ：“等等，我插一句，保证应用中一个类最多只有一个实例存在，并提供一个全局访问点访问它”。

只见OO先生会心一笑。

为什么用单例模式（Why）？

从What中貌似一目了然了，GOF和YSJIAN说的都是为了控制类的实例个数，表面上看YSJIAN的插话只是在重复GOF的描述，喜欢“咬文嚼字”的OO先生发现了这其中的玄机。首先回答一个问题：由谁类控制类的实例个数呢？

有人说：单利要多见简单有多简单，public static final INSTANCE = new Instance();你要用我的实例，Instance.INSTANCE拿走即可。的确，你发了一条广播出去，接收到的人会乐意按照你说的方法去使用，而不知道的人呢，更有new党，一上来就来一个new Instance()，然后到处开花，悲剧了。

怎么办？让Instance自己来控制实例的个数，而不是交给使用者，正所谓将邪恶扼杀于源头，可避免是是非非。当然这就需要Instance多干点活了。也没关系，一次搞定，服务持久，何乐而不为。

单例模式在哪里用（Where）？

我要说单利用在需要它的地方就有点zuo了。这么讲吧，如果这个类只需要一个实例即可满足我们的业务需求，或者它的实例一旦多余一个会出问题。比如说中国，China这个类如果不是单例就有点不合适了。一个工厂的中央炼钢炉，涉及到钢水，水，温度，气压这些危险地东西，一旦某个数值有差错就可能造成生产事故，这个时候炼钢炉存在多个实例就是万万不允许的，或者是有多个线程去操作非同步的它也是不合理的。

如何运用单例模式（How）？

单例，毫不夸张地说，是个开发者都能随手画出一个，赶紧上图：

public class LazyUnsafeSingleton {

   private volatile static LazyUnsafeSingleton instance;

   private LazyUnsafeSingleton() {
   }

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

貌似这个就可能出现问题，当多线程操作的时候，难保它能搞出几个实例来，于是YSJIAN加了几行代码，使用了第一招双重校验加同步:

public class LazyDoubleCheckSingleton {

   private volatile static LazyDoubleCheckSingleton instance;

   private LazyDoubleCheckSingleton() {
      Logger.getGlobal().info("LazyDoubleCheckSingleton.LazyDoubleCheckSingleton()");
   }

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

OO先生若有所思头地看着，边点头边吐出了一句：”内部类实例持有者可以让代码再简洁点...”，几分钟后，JSJIAN又上一副新图：

public class LazyHolderSingleton {

   private static class InstanceHolder {
      private static final LazyHolderSingleton INSTANCE = new LazyHolderSingleton();
   }

   private LazyHolderSingleton() {
      Logger.getGlobal().info("LazyHolderSingleton.LazyHOlderSingleton()");
   }

   public static LazyHolderSingleton getInstance() {
      return InstanceHolder.INSTANCE;
   }
}

细心的你已经发现了什么了？这几个单例，类名都是以Lazy为前缀。不用查找翻译啦，Lazy就是说这几单例很懒，没事就在那睡懒觉，什么时候叫他了(invoke:调用)，他就醒了，并开始为你效劳。

第一种，线程不安全；第二种，解决了线程安全问题。第三种，JVM类加载机制决定了它的线程安全。第四种…有第四种吗？这个可以有，也可以没有，不卖关子了，肯能你已经想到了，且看图：

public class LazyMethodSynSingleton {

    private static LazyMethodSynSingleton instance;

    private LazyMethodSynSingleton() {
        Logger.getGlobal().info("LazyMethodSynSingleton.LazyMethodSynSingleton()");
    }

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

不出意外，这个也是Lazy的，无非就是将双重校验加同步中的同步加到方法上了，我称之为方法同步。仔细揣摩两者的区别，不难发现：

双重校验加同步：只有Instace为null的时候加锁，而且这把锁几乎不用去管它。

方法同步：不论Instance是否为null，先加把锁再说，而且每次调用都会加锁。

对比完两者的区别，我想之前使用方法同步的同学就要赶紧转移阵地了，如果执意不想转的同学，试问一下：一个99%的情况下不需要加锁的，你去给加了把锁，是不是浪费很多不必要的时间，不合适，对吧，太伤感情，JVM会生气的！

到这里，懒汉式单例经典实现就是上面的四种了，第一种，因为无意识而没有安全感，第四种因为对危险充满恐惧，徒耗精力。选项貌似一下子砍了50%，至于使用哪种，随心，随性就好，我遵循代码简洁之道（此处并不是特指Robert C. Martin的Clean Code），选择了内部类实例持有者。

懒汉子即将返璞归真，退出舞台，且看下个回合饿汉子如何搔首弄姿。

PS : OO先生,YSJIAN,GOF，等加粗斜体的表示人名，详细内容欢迎回顾《开启设计之旅》。亲爱的同仁，若有疑问，欢迎留言交流。

其他参考：

设计模式(001) 开启设计之旅

设计模式(002) 模式语录

设计模式(003) 单例模式[上] 单身懒汉

标签：设计模式面向对象敏捷开发单例模式懒汉式