java.lang.Shutdown

package java.lang;

import java.util.HashSet;
import java.util.Iterator;

/**
 *
 *
 * 管理关闭序列
 *
 * comment by liqiang
 *
 * @author   Mark Reinhold
 *
 */

class Shutdown {
 
 //一个静态内部类,用来封装一个Thread对象,保证两个线程完全相等(通过比较
 //内存地址相等,而不是通过equals方法的相等)
    private static class WrappedHook {

 private Thread hook;

 WrappedHook(Thread t) {
     hook = t;
 }

 public int hashCode() {
     return System.identityHashCode(hook);
 }

 public boolean equals(Object o) {
  //如果不是此类对象(不是此类对象内存地址肯定不等)直接返回false
     if (!(o instanceof WrappedHook)) return false;
     //比较内存地址是否相等
     return (((WrappedHook)o).hook == hook);
 }

    }

    //关闭状态
    private static final int RUNNING = 0;
    private static final int HOOKS = 1;
    private static final int FINALIZERS = 2;
   
    //单前的初始状态为RUNNING
    private static int state = RUNNING;

    //是否在退出时运行清除操作
    private static boolean runFinalizersOnExit = false;

    /* The set of registered, wrapped hooks, or null if there aren't any */
    //关闭钩注册的地方,初始化为null表示不含有关闭钩
    private static HashSet hooks = null;

    //静态内部类,用来生成同步的锁
    private static class Lock { };
    //一个静态对象表示锁
    private static Object lock = new Lock();

    //是否在退出时运行清除操作的标志
    static void setRunFinalizersOnExit(boolean run) {
 synchronized (lock) {
     runFinalizersOnExit = run;
 }
    }

    /*
     *
     * 添加一个新的的关闭钩
     *
     */
    static void add(Thread hook) {
 synchronized (lock) {
  //如果当前ShutDown对象不是运行状态,抛出异常
     if (state > RUNNING)
  throw new IllegalStateException("Shutdown in progress");
     //如果线程还Alive则抛出异常
     if (hook.isAlive())
  throw new IllegalArgumentException("Hook already running");
    
     if (hooks == null) {
     //hooks Set为空则创建新的hooks Set并将此线程对象封装成WrappedHook加入 
  hooks = new HashSet(11);
  hooks.add(new WrappedHook(hook));
  
  Terminator.setup();
  
     } else {
     //封装成WrappedHook对象
  WrappedHook wh = new WrappedHook(hook);
  //如果此封装对象已经存在则抛出异常
  if (hooks.contains(wh))
      throw new IllegalArgumentException("Hook previously registered");
  
  //添加此封装对象
  hooks.add(wh);
     }
 }
    }

    /*
     *
     * 删除注册过的关闭钩
     *
     */
    static boolean remove(Thread hook) {
 synchronized (lock) {
  //如果此对象不是运行状态抛出异常
     if (state > RUNNING)
  throw new IllegalStateException("Shutdown in progress");
    
     if (hook == null) throw new NullPointerException();
    
     //如果hooks为null表示没有注册过关闭钩则直接返回false
     if (hooks == null) {
  return false;
     } else {
     //从set中删除相应的WrappedHook
  boolean rv = hooks.remove(new WrappedHook(hook));
  
  //如果删除成功,且set为空,则将set清空
  if (rv && hooks.isEmpty()) {
      hooks = null;
     
      //此方法现在不支持
      Terminator.teardown();
  }
  return rv;
     }
 }
    }

    /*
     *
     * 运行所有注册的关闭钩
     *
     */
    private static void runHooks() {
 if (hooks == null) return;
 //启动注册的线程
 for (Iterator i = hooks.iterator(); i.hasNext();) {
     ((WrappedHook)(i.next())).hook.start();
 }
 //等待每个线程死去
 for (Iterator i = hooks.iterator(); i.hasNext();) {
     try {
  ((WrappedHook)(i.next())).hook.join();
     } catch (InterruptedException x) {
  continue;
     }
 }
    }

   //停止
    static native void halt(int status);

    //运行清除操作
    private static native void runAllFinalizers();

    /*
     * 此方法定义了关闭的序列
     */
    private static void sequence() {
 synchronized (lock) {
     if (state != HOOKS) return;
 }
 //运行所有注册的hook
 runHooks();
 boolean rfoe;
 synchronized (lock) {
  //设置状态为FINALIZERS
     state = FINALIZERS;
     rfoe = runFinalizersOnExit;
 }
 //如果在虚拟机退出时进行清除操作则运行此操作
 if (rfoe) runAllFinalizers();
    }

    /*
     * 关闭虚拟机,由Runtime.exit调用
     */
    static void exit(int status) {
 boolean runMoreFinalizers = false;
 
 synchronized (lock) {
  //如果不是运行状态,则设置状态为退出时不做清除操作
     if (status != 0) runFinalizersOnExit = false;
    
     //根据不同状态做不同的处理
     switch (state) {
     case RUNNING: //设置为HOOKS状态
  state = HOOKS;
  break;
     case HOOKS:  //不作操作
  break;
     case FINALIZERS: //FINALIZERS情况
  if (status != 0) {
      //停止
      halt(status);
  } else {
      runMoreFinalizers = runFinalizersOnExit;
  }
  break;
     }
 }
 
 if (runMoreFinalizers) {
     //退出时需要做清除操作
  runAllFinalizers();
  //停止
     halt(status);
 }
 
 synchronized (Shutdown.class) {
     //顺序关闭
     sequence();
     //停止
     halt(status);
 }
    }

    static void shutdown() {
 synchronized (lock) {
     switch (state) {
     case RUNNING: /* Initiate shutdown */
  state = HOOKS;
  break;
     case HOOKS:  /* Stall and then return */
     case FINALIZERS:
  break;
     }
 }
 
 synchronized (Shutdown.class) {
     sequence();
 }
    }

}