ShutdownHook优雅停机

背景

通常在我们重启应用服务时候，有些请求还没有执行完毕，此时我们想要等当前请求执行完毕之后，然后再进行停机操作，此时就用到了ShutdownHook 。

用法

使用ShutdownHook，我们可以向jvm注册一个钩子，这个钩子其实就是一条线程，在应用停机时候，会触发这个线程，此时只要再这个钩子里面写上我们需要的操作即可。
注意：这里说的停机，不是强制停止。强制停机（kill -9）是不会触发钩子的。如下操作可以触发：
1. 程序正常退出
2. 使用System.exit()
3. 终端使用Ctrl+C触发的中断
4. 系统关闭
5. 使用Kill pid命令干掉进程。

案例：

假设有一个线程池如下，每两秒钟添加一个任务执行，如果我们直接kill线程的话，必然会导致，很多任务添加进去了，但是由于粗暴停机，导致没有执行。

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Service
@Slf4j
public class Task {

    public static ExecutorService executorService  = Executors.newFixedThreadPool(10);

    public static boolean flag = false;

    // 假设有一个线程池，每两秒钟就要处理一个任务。如果直接停机的话，会导致任务丢失
    public void start() {
        while (true) {
            try {
                // 任务开关
                if(flag) return;
                final String i = RandomStringUtils.randomAlphabetic(6);
                log.info("添加执行第-------{}-------号任务", i);
                Thread.sleep(2000);
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 比如任务需要处理4秒
                            Thread.sleep(4000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        log.info("第-------{}-------号任务已经处理完成", i);
                    }
                });
                log.info("执行结束-------------");

            } catch (Exception e) {
                log.info("处理异常-------------", e);
            }
        }
    }

    // 使用PostConstruct自动执行
    @PostConstruct
    private void init(){
        //  这里踩了一坑，本来想写简单点，直接把start()方法中的while(true)那一块东西放在在PostConstruct里面，发现主线程（main）一直在这里循环，卡着。没有完全启动
        //  所以要用额外线程启动，不要在PostConstruct写执行不完的循环方法。
        Executors.newSingleThreadExecutor().execute(new Runnable() {
            @Override
            public void run() {
                start();
            }
        });
    }
}

执行结果一，不使用shutdownhook

运行上面代码，执行kill pid命令（注意不要使用kill -9，强制停机不会触发hook）。会显示如下：

由于粗暴停机，导致后面三次添加的任务丢失，并没有等待线程池执行完毕。

添加shutdownhook

此时，我们可以自定义一个shutdownHook，在停机时多等待一些时间，让线程池的任务执行完毕。

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Slf4j
@Service
public class HookConfig {

    @PostConstruct
    private void init() {
        // 定义hook
        Thread shutdownHook = new Thread() {
            @Override
            public void run() {
                try {
                    log.info("触发hook");
                    // 这里可以写我们需要的操作，如停止当前定时任务，停止线程池或是关闭入口等，而不是立即停止。

                    // 关闭任务入口，
                    Task.flag = true;
                    // 等待3秒，让当前任务，进入executorService线程池。
                    Thread.sleep(3000);
                    
                    // 3秒后关闭线程池，但是，线程池里面没执行完的任务会继续执行
                    Task.executorService.shutdown();
                    
                    // 这里设置等待10秒，让线程池里面的任务执行，10秒后，强制停机。
                    Thread.sleep(10 * 1000);
                    log.info("已停止");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // 向jvm注册hook
        Runtime.getRuntime().addShutdownHook(shutdownHook);
    }
}

执行结果二，使用shutdownhook

程序启动，执行kill pid （注意不要使用kill -9，强制停机不会触发hook）
此时执行结果如下：

可以看到每一个进入线程池的任务，都会执行完毕，因为触发了上面定义hook，会等待里面指定的时间，不会立即停机，导致任务丢失。

附上启动脚本和停止脚本

start.sh

nohup java -jar  test-server.jar > test.log &

shutdown.sh

pid=`ps -ef|grep  test-server.jar  |grep -v grep|awk '{print $2}'`
if [ ! $pid ]; then
   echo $"   test-server is stopped"
else
   echo -n $"Stopping  test-server"        
   kill  $pid
   echo [ OK ] 
fi

shutDownHook使用升级版

		//设置关闭钩子
        Runtime.getRuntime().addShutdownHook(new Thread(){
            @Override
            public void run() {
                executor.shutdown();
                //设定最大重试次数
                int retry = 2;
                try {
                    //每次等待 10 s，重试
                    if (!executor.awaitTermination(10, TimeUnit.SECONDS) && retry-- > 0) {
                        if (retry == 1){
                            //调用shutdownNow()取消正在执行的任务，SHUTDOWN->STOP是被允许的
                            executor.shutdownNow();
                        }else {
                            log.error("线程池任务未正常执行结束");
                        }
                    }
                } catch (InterruptedException ie) {
                    //重新调用 shutdownNow
                    executor.shutdownNow();
                }
            }
        });

JVM钩子调用过程

• awaitTermination(long timeout, TimeUnit unit)
  该方法若线程池状态为TERMINATED，则返回true，否则会等待timeout时长，若等待超时，则返回false，表示线程仍未关闭终结
  简单来说就是查看当前线程的状态。超时未返回返回false

 public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (;;) {
                if (runStateAtLeast(ctl.get(), TERMINATED))
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }