Hadoop里的设计模式之单例模式

单例模式是创建性模式之一，算是比较简单好理解的了。

单例模式:保证一个类仅有一个实例，并提供一个访问它的全局访问点。

我们以Hadoop2.7版本中的ShutdownHookManager举例讲解单例模式的几个需要注意的地方：
1）将构造方法私有化。单例模式通常是在类内部提供一个可供使用的对象，通过公共接口对外提供该对象。为了避免在类外面通过new的方式再次生成对象，通常都会将构造方法私有化。
2）采用饿汉式。所谓的饿汉式，是在类内部固定生成一个对象，而不管这个对象是否会真正使用。优点的话是实现起来比较简单，且是jdk内部比如Runtime这个单例类的默认实现，缺点是如果对象没有被使用，会浪费一些存储。
3）提供一个静态的公共访问接口，获取单例。

public class ShutdownHookManager {

  private static final ShutdownHookManager MGR = new ShutdownHookManager();

  private static final Log LOG = LogFactory.getLog(ShutdownHookManager.class);

  static {
    Runtime.getRuntime().addShutdownHook(
      new Thread() {
        @Override
        public void run() {
          MGR.shutdownInProgress.set(true);
          for (Runnable hook: MGR.getShutdownHooksInOrder()) {
            try {
              hook.run();
            } catch (Throwable ex) {
              LOG.warn("ShutdownHook '" + hook.getClass().getSimpleName() +
                       "' failed, " + ex.toString(), ex);
            }
          }
        }
      }
    );
  }

  /**
   * Return ShutdownHookManager singleton.
   *
   * @return ShutdownHookManager singleton.
   */
  public static ShutdownHookManager get() {
    return MGR;
  }

  /**
   * Private structure to store ShutdownHook and its priority.
   */
  private static class HookEntry {
    Runnable hook;
    int priority;

    public HookEntry(Runnable hook, int priority) {
      this.hook = hook;
      this.priority = priority;
    }

    @Override
    public int hashCode() {
      return hook.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
      boolean eq = false;
      if (obj != null) {
        if (obj instanceof HookEntry) {
          eq = (hook == ((HookEntry)obj).hook);
        }
      }
      return eq;
    }

  }

  private Set hooks =
    Collections.synchronizedSet(new HashSet());

  private AtomicBoolean shutdownInProgress = new AtomicBoolean(false);

  //private to constructor to ensure singularity
  private ShutdownHookManager() {
  }

  /**
   * Returns the list of shutdownHooks in order of execution,
   * Highest priority first.
   *
   * @return the list of shutdownHooks in order of execution.
   */
  List getShutdownHooksInOrder() {
    List list;
    synchronized (MGR.hooks) {
      list = new ArrayList(MGR.hooks);
    }
    Collections.sort(list, new Comparator() {

      //reversing comparison so highest priority hooks are first
      @Override
      public int compare(HookEntry o1, HookEntry o2) {
        return o2.priority - o1.priority;
      }
    });
    List ordered = new ArrayList();
    for (HookEntry entry: list) {
      ordered.add(entry.hook);
    }
    return ordered;
  }

  /**
   * Adds a shutdownHook with a priority, the higher the priority
   * the earlier will run. ShutdownHooks with same priority run
   * in a non-deterministic order.
   *
   * @param shutdownHook shutdownHook Runnable
   * @param priority priority of the shutdownHook.
   */
  public void addShutdownHook(Runnable shutdownHook, int priority) {
    if (shutdownHook == null) {
      throw new IllegalArgumentException("shutdownHook cannot be NULL");
    }
    if (shutdownInProgress.get()) {
      throw new IllegalStateException("Shutdown in progress, cannot add a shutdownHook");
    }
    hooks.add(new HookEntry(shutdownHook, priority));
  }

  /**
   * Removes a shutdownHook.
   *
   * @param shutdownHook shutdownHook to remove.
   * @return TRUE if the shutdownHook was registered and removed,
   * FALSE otherwise.
   */
  public boolean removeShutdownHook(Runnable shutdownHook) {
    if (shutdownInProgress.get()) {
      throw new IllegalStateException("Shutdown in progress, cannot remove a shutdownHook");
    }
    return hooks.remove(new HookEntry(shutdownHook, 0));
  }

  /**
   * Indicates if a shutdownHook is registered or not.
   *
   * @param shutdownHook shutdownHook to check if registered.
   * @return TRUE/FALSE depending if the shutdownHook is is registered.
   */
  public boolean hasShutdownHook(Runnable shutdownHook) {
    return hooks.contains(new HookEntry(shutdownHook, 0));
  }

  /**
   * Indicates if shutdown is in progress or not.
   * 
   * @return TRUE if the shutdown is in progress, otherwise FALSE.
   */
  public boolean isShutdownInProgress() {
    return shutdownInProgress.get();
  }

}