设计模式1：单例模式

在平时工作中，很多时候遇见的任务其实都有多种实现方法，或者说有不同的代码设计。
当然，就安卓开发而言，最重要的就是刚开始的架构。不过后来实现具体业务的代码同样可以追求更“优雅”一些。
何谓“优雅”？编程里面的优雅，无非就是在确保正确性、稳定性的前提下，做到：

• 逻辑清晰，易于理解
• 耦合度低，容易复用
• 高效
• 短

实际上，说起来就这么一些，真正做起来可不容易。光正确性、稳定性就要花很大功夫，在这之外考虑一些东西，就是难上加难。
好在大部分问题别人都遇到并且解决过，而长久以来积累的一些编程的经验，就成为了设计模式（Design Patterns）。
所以说，为什么要用设计模式？因为用了设计模式之后代码会比较“优雅”。
当然，罗老师说的好，没有设计就是最好的设计。设计模式只是一种参考，不能生搬硬套。否则还真不如没有。
今天就来学一学最简单的——单例模式（Singleton）。

单例模式

基本概念

这个模式的意图是希望对象只创建一个实例，并且提供一个全局的访问点。
为什么要用单例模式？单例模式的对面自然是多例，为什么不能有多个实例呢？
答案很明显，一是节约资源，比如SimpleDateFormat，到处创建的话，效率肯定不如单个的好（当然这个类线程不安全，复用的时候需要注意）；二是方便管理，比如DB的Manager类，1个DB只需要1个Manager，多了的话反而会变得混乱。
同样的，单例模式的局限性也很明显：

• 全局可见，可能要考虑线程安全性；
• 全局调用，因此难以释放；
• 继承基本上没用；
• 耦合度高。

创建方法

就大体而言，我把单例模式的创建方法分成两种：

1.预先初始化（Eager Initialization）

预先初始化的意思就是，只要有机会就创建实例。这个方法是线程安全的（因为没有带入更多逻辑，这里说的线程安全都是对创建单例而言）。

2. 延迟初始化（Lazy Initialization）

和1相反，是在最后时刻也就是马上要用的时候来创建实例。这个不是天生线程安全的，需要做一些处理。处理又有不同的处理方法，具体再说。

代码

废话不多说，上代码了（出处参考这里）：

1. 预先初始化

/**
 * Singleton class. Eagerly initialized static instance guarantees thread safety.
 */
public final class IvoryTower {

  /**
   * Private constructor so nobody can instantiate the class.
   */
  private IvoryTower() {}

  /**
   * Static to class instance of the class.
   */
  private static final IvoryTower INSTANCE = new IvoryTower();

  /**
   * To be called by user to obtain instance of the class.
   *
   * @return instance of the singleton.
   */
  public static IvoryTower getInstance() {
    return INSTANCE;
  }
}

这个类就是最简单的预先加载单例模式。私有构造方法从而不会被外界调用，私有静态实例创建，因此叫做“预加载”。同时final修饰，不可变。
这个方法是线程安全的，因为实例在被调用之前已经生成，而且不可变。缺点自然是有浪费资源的嫌疑，因为没被调用时已经占用了内存。
适用场景：

• 需要经常使用；
• 不会占用太多资源。

2.基于枚举的预先初始化

/**
 * Enum based singleton implementation. Effective Java 2nd Edition (Joshua Bloch) p. 18
 */
public enum EnumIvoryTower {

  INSTANCE;

  @Override
  public String toString() {
    return getDeclaringClass().getCanonicalName() + "@" + hashCode();
  }
}

使用时调用EnumIvoryTower.INSTANCE。
看上去更加简单，也线程安全，原理和1类似。不过需要注意的是扩展会受到限制：继承、序列化等等。

3. 线程安全的延迟初始化

/**
 * Thread-safe Singleton class. The instance is lazily initialized and thus needs synchronization
 * mechanism.
 *
 * Note: if created by reflection then a singleton will not be created but multiple options in the
 * same classloader
 */
public final class ThreadSafeLazyLoadedIvoryTower {

  private static ThreadSafeLazyLoadedIvoryTower instance;

  private ThreadSafeLazyLoadedIvoryTower() {}

  /**
   * The instance gets created only when it is called for first time. Lazy-loading
   */
  public static synchronized ThreadSafeLazyLoadedIvoryTower getInstance() {

    if (instance == null) {
      instance = new ThreadSafeLazyLoadedIvoryTower();
    }

    return instance;
  }
}

这个方法就是在被调用实例的时候去创建一个，而为了线程安全，使用synchronized 来修饰getInstance方法。好处就是资源分配更合理，要用了才占资源；坏处就是速度慢了，创建可能会慢，而且多个线程一起访问的时候还有锁。

4. 线程安全的双重检验锁延迟初始化

/**
 * Double check locking
 * 

 * http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
 * 

 * Broken under Java 1.4.
 *
 * @author [email protected]
 */
public final class ThreadSafeDoubleCheckLocking {

  private static volatile ThreadSafeDoubleCheckLocking instance;

  /**
   * private constructor to prevent client from instantiating.
   */
  private ThreadSafeDoubleCheckLocking() {
    // to prevent instantiating by Reflection call
    if (instance != null) {
      throw new IllegalStateException("Already initialized.");
    }
  }

  /**
   * Public accessor.
   *
   * @return an instance of the class.
   */
  public static ThreadSafeDoubleCheckLocking getInstance() {
    // local variable increases performance by 25 percent
    // Joshua Bloch "Effective Java, Second Edition", p. 283-284
    
    ThreadSafeDoubleCheckLocking result = instance;
    // Check if singleton instance is initialized. If it is initialized then we can return the instance.
    if (result == null) {
      // It is not initialized but we cannot be sure because some other thread might have initialized it
      // in the meanwhile. So to make sure we need to lock on an object to get mutual exclusion.
      synchronized (ThreadSafeDoubleCheckLocking.class) {
        // Again assign the instance to local variable to check if it was initialized by some other thread
        // while current thread was blocked to enter the locked zone. If it was initialized then we can 
        // return the previously created instance just like the previous null check.
        result = instance;
        if (result == null) {
          // The instance is still not initialized so we can safely (no other thread can enter this zone)
          // create an instance and make it our singleton instance.
          instance = result = new ThreadSafeDoubleCheckLocking();
        }
      }
    }
    return result;
  }
}

这个是3的加强版，提高了效率，但是代价就是代码的复杂度。Java 1.4以下不可用。
其实很精妙，instance用volatile修饰，虽然是静态变量但刚开始并没有初始化。Volatile的意思就是不会被重排序，读取的总是最后写入的值。当然光靠Volatile并不能解决线程安全问题，因为可能两个线程同时读之后再写。因此后面还有一个synchronized (ThreadSafeDoubleCheckLocking.class)，直接锁类。
假设两个线程AB先后尝试获取instance，假如线程不安全，后果就是创建两遍instance。在这里，A肯定不会创两遍，主要看B，B进来的时候假如A已经完事了自然好说，假设A还在创建当中，B一看是null，准备去创建，发现门被锁上了（synchronized），等到门开了的时候，A已经出来了，也在里面创建了实例，B再看的时候就不是null了。
4比3快，因为只同步块而不是方法。

5. InitializingOnDemandHolderIdiom（实在不知道怎么翻译）

/**
 * The Initialize-on-demand-holder idiom is a secure way of creating a lazy initialized singleton
 * object in Java.
 * 

 * The technique is as lazy as possible and works in all known versions of Java. It takes advantage
 * of language guarantees about class initialization, and will therefore work correctly in all
 * Java-compliant compilers and virtual machines.
 * 

 * The inner class is referenced no earlier (and therefore loaded no earlier by the class loader) than
 * the moment that getInstance() is called. Thus, this solution is thread-safe without requiring special
 * language constructs (i.e. volatile or synchronized).
 *
 */
public final class InitializingOnDemandHolderIdiom {

  /**
   * Private constructor.
   */
  private InitializingOnDemandHolderIdiom() {}

  /**
   * @return Singleton instance
   */
  public static InitializingOnDemandHolderIdiom getInstance() {
    return HelperHolder.INSTANCE;
  }

  /**
   * Provides the lazy-loaded Singleton instance.
   */
  private static class HelperHolder {
    private static final InitializingOnDemandHolderIdiom INSTANCE =
        new InitializingOnDemandHolderIdiom();
  }
}

这个方法使用了静态内部类来获得实例，原理就是内部类在被调用之前不会创建实例。代码量少，不需要手动同步。

总结

不要看单例模式看起来简单，大神们的实现都是直指Java核心，编译原理，线程安全，都考虑到了。这5种方法就是大浪淘沙，无数程序员智慧的结晶。具体使用哪种方法得看需求。