哦，这就是java的优雅停机？（实现及原理）

public class ShutdownGracefulTest {    /**     * 使用线程池处理任务     */    public static ExecutorService executorService = Executors.newCachedThreadPool();    public static void main(String[] args) {        //假设有5个线程需要执行任务        for(int i = 0; i < 5; i++){            final int id = i;            Thread taski = new Thread(new Runnable() {                @Override                public void run() {                    System.out.println(System.currentTimeMillis() + " : thread_" + id + " start...");                    try {                        TimeUnit.SECONDS.sleep(id);                    }                    catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(System.currentTimeMillis() + " : thread_" + id + " finish!");                }            });            taski.setDaemon(true);            executorService.submit(taski);        }        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {            @Override            public void run() {                System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No1 shutdown hooking...");                boolean shutdown = true;                try {                    executorService.shutdown();                    System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() +  " shutdown signal got, wait threadPool finish.");                    executorService.awaitTermination(1500, TimeUnit.SECONDS);                    boolean done = false;                    System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() +  " all thread's done.");                }                catch (InterruptedException e) {                    e.printStackTrace();                    // 尝试再次关闭                    if(!executorService.isTerminated()) {                        executorService.shutdownNow();                    }                }                System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No1 shutdown done...");            }        }));        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {            @Override            public void run() {                try {                    System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No2 shutdown hooking...");                    Thread.sleep(1000);                }                catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No2 shutdown done...");            }        }));        System.out.println("main method exit...");        System.exit(0);    }}

executorService.shutdown();executorService.awaitTermination(1500, TimeUnit.SECONDS);

    /**     * Registers a new virtual-machine shutdown hook.     *     * @param   hook     *          An initialized but unstarted <tt>{@link Thread}</tt> object     *     * @throws  IllegalArgumentException     *          If the specified hook has already been registered,     *          or if it can be determined that the hook is already running or     *          has already been run     *     * @throws  IllegalStateException     *          If the virtual machine is already in the process     *          of shutting down     *     * @throws  SecurityException     *          If a security manager is present and it denies     *          <tt>{@link RuntimePermission}("shutdownHooks")</tt>     *     * @see #removeShutdownHook     * @see #halt(int)     * @see #exit(int)     * @since 1.3     */    public void addShutdownHook(Thread hook) {        SecurityManager sm = System.getSecurityManager();        if (sm != null) {            sm.checkPermission(new RuntimePermission("shutdownHooks"));        }        // 添加到 application 中        ApplicationShutdownHooks.add(hook);    }    // java.lang.ApplicationShutdownHooks.add(hook);    static synchronized void add(Thread hook) {        if(hooks == null)            throw new IllegalStateException("Shutdown in progress");        if (hook.isAlive())            throw new IllegalArgumentException("Hook already running");        if (hooks.containsKey(hook))            throw new IllegalArgumentException("Hook previously registered");        // hooks 以map类型保存, k->k 形式存储，保证每一个钩子都是独立的        hooks.put(hook, hook);    }    // java.lang.ApplicationShutdownHooks 会先注册一个静态块，添加一个任务到 Shutdown 中    /* The set of registered hooks */    private static IdentityHashMap<Thread, Thread> hooks;    static {        try {            Shutdown.add(1 /* shutdown hook invocation order */,                false /* not registered if shutdown in progress */,                new Runnable() {                    public void run() {                        // 即当该任务被调用时，调用自身的运行方法，使所有注册的 hook 运行起来                        runHooks();                    }                }            );            hooks = new IdentityHashMap<>();        } catch (IllegalStateException e) {            // application shutdown hooks cannot be added if            // shutdown is in progress.            hooks = null;        }    }    // runHooks 执行所有钩子线程,进行异步调用    /* Iterates over all application hooks creating a new thread for each     * to run in. Hooks are run concurrently and this method waits for     * them to finish.     */    static void runHooks() {        Collection<Thread> threads;        synchronized(ApplicationShutdownHooks.class) {            threads = hooks.keySet();            hooks = null;        }        for (Thread hook : threads) {            hook.start();        }        for (Thread hook : threads) {            try {                // 阻塞等待所有完成                hook.join();            } catch (InterruptedException x) { }        }    }

    // java.lang.Shutdown.add() 该方法会jvm主动调用，从而触发 后续钩子执行    /* Invoked by the JNI DestroyJavaVM procedure when the last non-daemon     * thread has finished.  Unlike the exit method, this method does not     * actually halt the VM.     */    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();        }    }    // 而 sequence() 则会调用 runHooks(), 调用自定义的钩子任务    private static void sequence() {        synchronized (lock) {            /* Guard against the possibility of a daemon thread invoking exit             * after DestroyJavaVM initiates the shutdown sequence             */            if (state != HOOKS) return;        }        runHooks();        boolean rfoe;        synchronized (lock) {            state = FINALIZERS;            rfoe = runFinalizersOnExit;        }        if (rfoe) runAllFinalizers();    }    // 执行钩子，此处最多允许注册 10 个钩子，且进行同步调用，当然这是最顶级的钩子，钩子下还可以添加钩子，可以任意添加n个    private static void runHooks() {        for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {            try {                Runnable hook;                synchronized (lock) {                    // acquire the lock to make sure the hook registered during                    // shutdown is visible here.                    currentRunningHook = i;                    hook = hooks[i];                }                // 同步调用注册的hook, 即 前面看到 ApplicationShutdownHooks.runHooks()                if (hook != null) hook.run();            } catch(Throwable t) {                if (t instanceof ThreadDeath) {                    ThreadDeath td = (ThreadDeath)t;                    throw td;                }            }        }    }