哦,这就是java的优雅停机?(实现及原理)

其实优雅停机,就是在要关闭服务之前,不是立马全部关停,而是做好一些善后操作,比如:关闭线程、释放连接资源等。

再比如,就是不会让调用方的请求处理了一增,一下就中断了。而处理完本次后,再停止服务。

Java语言中,我们可以通过Runtime.getRuntime().addShutdownHook()方法来注册钩子,以保证程序平滑退出。(其他语言也类似)

来个栗子:

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);    }}

运行结果如下:

很明显,确实是优雅了,虽然最后收到了一关闭信号,但是仍然保证了任务的处理完成。很棒吧!

 那么,在实际应用中是如何体现优雅停机呢?

kill -15 pid

通过该命令发送一个关闭信号给到jvm, 然后就开始执行 Shutdown Hook 了,你可以做很多:

  1. 关闭 socket 链接
  2. 清理临时文件
  3. 发送消息通知给订阅方,告知自己下线
  4. 将自己将要被销毁的消息通知给子进程
  5. 各种资源的释放 ...

而在平时工作中,我们不乏看到很多运维同学,是这么干的:

kill -9 pid

如果这么干的话,jvm也无法了,kill -9 相当于一次系统宕机,系统断电。这会给应用杀了个措手不及,没有留给应用任何反应的机会。

所以,无论如何是优雅不起来了。

要优雅,是代码和运维的结合!

其中,线程池的关闭方式为:

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

ThreadPoolExecutor 在 shutdown 之后会变成 SHUTDOWN 状态,无法接受新的任务,随后等待正在执行的任务执行完成。意味着,shutdown 只是发出一个命令,至于有没有关闭还是得看线程自己。

ThreadPoolExecutor 对于 shutdownNow 的处理则不太一样,方法执行之后变成 STOP 状态,并对执行中的线程调用 Thread.interrupt() 方法(但如果线程未处理中断,则不会有任何事发生),所以并不代表“立刻关闭”。

  • shutdown() :启动顺序关闭,其中执行先前提交的任务,但不接受新任务。如果已经关闭,则调用没有附加效果。此方法不等待先前提交的任务完成执行。
  • shutdownNow():尝试停止所有正在执行的任务,停止等待任务的处理,并返回正在等待执行的任务的列表。当从此方法返回时,这些任务将从任务队列中耗尽(删除)。此方法不等待主动执行的任务终止。
  • executor.awaitTermination(this.awaitTerminationSeconds, TimeUnit.SECONDS)); 控制等待的时间,防止任务无限期的运行(前面已经强调过了,即使是 shutdownNow 也不能保证线程一定停止运行)。

注意:

  • 虚拟机会对多个shutdownhook以未知的顺序调用,都执行完后再退出。
  • 如果接收到 kill -15 pid 命令时,执行阻塞操作,可以做到等待任务执行完成之后再关闭 JVM。同时,也解释了一些应用执行 kill -15 pid 无法退出的问题,如:中断被阻塞了,或者hook运行了死循环代码。

实现原理:

Runtime.getRuntime().addShutdownHook(hook); // 添加钩子,开启优雅之路

// 具体流程如下:

    /**     * 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;                }            }        }    }

如此,整个关闭流程完美了。

简化为:

  1. 注册流程(应用主动调用):Runtime.addShutdownHook -> ApplicationShutdownHooks.add()/static -> java.lang.Shutdown.add()/shutdown()
  2. 执行流程(jvm自动调用):java.lang.Shutdown.shutdown()->sequence()->runHooks() -> ApplicationShutdownHooks.runHooks() -> hooks 最终

出处:https://www.cnblogs.com/yougewe/p/9881874.html

原文发布于微信公众号 - Java技术驿站(chenssy89)

原文发表时间:2018-11-05

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏菩提树下的杨过

利用sharding-jdbc分库分表

sharding-jdbc是当当开源的一款分库分表的数据访问层框架,能对mysql很方便的分库、分表,基本不用修改原有代码,只要配置一下即可,完整的配置参考以下...

3317
来自专栏不会写文章的程序员不是好厨师

日志那些事儿——Logback源码解析

在上篇文章日志漫谈中谈到,日志在监控报警、查错分析等方面有着非常重要的应用。Logback作为目前最火的日志系统,本文就简单分析一下logback日志打印的过程...

4352
来自专栏小灰灰

SpringMVC返回图片的几种方式

SpringMVC返回图片的几种方式 后端提供服务,通常返回的json串,但是某些场景下可能需要直接返回二进制流,如一个图片编辑接口,希望直接将图片流返回给前...

66010
来自专栏LanceToBigData

JavaWeb(三)JSP之3个指令、6个动作、9个内置对象和4大作用域

前言   前面大概介绍了什么是JSP,今天我给大家介绍一下JSP的三个指令、6个动作以及它的9大内置对象。接下来我们就直接进入正题 一、JSP的3个指令 JSP...

2907
来自专栏java技术学习之道

Spring中获取request的几种方法,及其线程安全性分析

2537
来自专栏大内老A

ASP.NET Core的配置(4):多样性的配置来源[中篇]

我们在本篇文章中会介绍三种针对物理文件的ConfiguationProvider,它们分别是针对JSON文件的JsonConfiguationProvider,...

2058
来自专栏古时的风筝

Spring 实现自定义 bean 的扩展

Spring mvc 提供了扩展 xml 的机制,用来编写自定义的 xml bean ,例如 dubbo 框架,就利用这个机制实现了好多的 dubbo bean...

2328
来自专栏木木玲

Netty 源码解析 ——— ChannelConfig 和 Attribute

2572
来自专栏机器学习从入门到成神

在MyEclipse中使用Junit 的方法

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_35512245/articl...

971
来自专栏大内老A

ASP.NET MVC Controller激活系统详解:默认实现

Controller激活系统最终通过注册的ControllerFactory创建相应的Conroller对象,如果没有对ControllerFactory类型或...

2309

扫码关注云+社区

领取腾讯云代金券