优雅停机

最近我们公司有一个优雅停机的需求，正好我也参与其中，于是就顺便了解了一些原理。什么是优雅停机，字面的意思就是优雅的停机，如何优雅的停机呢？首先我们要把停机前接受的请求都处理掉吧，光处理请求还不行，你还得不让新的请求进来（引流挡板）。

具体的实现

我看网上写的优雅停机大部分都是使用showdownhook()钩子来实现停机前的处理，也就是如下的代码：

/**
 * 优雅停机处理方式
 * 
 **/
public class Main{ 
    /**
     * 启动应用
     **/
    public void start(){
        // 第一步：启动应用服务……
        // 第二步：注册JDK钩子
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("The hook running...");
                //第三步：调用停机处理
                stop();
            }
        }));
    }
    /**
     * 停止应用
     **/
    public void stop(){
        // 停止应用前停机处理(如：注销服务、标记不接受请求等)
    }
}

但是，我们公司实现方式还是有一点点差别的。我们公司里利用jvm对操作系统进程信号signal的处理来实现停机前的处理。主要有三点需要注意的：

1. 在接受到进程信号signal的时候，第一步要做的就是引流挡板，也就是下掉当前服务机器在注册中心的节点，使得当前的一些请求负载到其他的服务器上，当前服务器不在接受服务请求。
2. 然后就是处理那些已经在工作的请求，怎么确定有哪些请求还在处理中呢？这个问题的解决我们是用的一个叫当前工作数的过滤器来计数当前真正进行的请求数。当然，有些请求特别慢或者有些请求处理超时，我们不可能一直无限等待的，所以还得有个超时时间。过了超时时间，就会强制关机。
3. 当然这一切的实现逻辑都是在我们能接受到进程的信号，并且做出相应的反应，也就牵扯到我们的核心代码信号处理。

下面是一些具体的实现：
我们公司用的etcd来做配置中心和服务的注册和发现，当然也可以用zookeeper来实现的。

package test;

import java.util.concurrent.atomic.AtomicInteger;

import javax.servlet.http.HttpServlet;

public class StartUpServlet extends HttpServlet
{
    private final static DebugLog log = LogFactory.getDebugLog(StartUpServlet.class);

    private static final AtomicInteger working = new AtomicInteger(0);

    public void init() {
        System.out.println("init start!");
        initSignal();
    }
    private void initSignal()
    {
        // 初始化自定义信号USR2
        Signal signal = new Signal("USR2");
        // 接收到信号后调用handle
        Signal.handle(signal, new SignalHandler()
        {
            
            @Override
            public void handle(Signal signal)
            {
                //通知nginx下掉服务器节点
                deleteEtcdInfo();
                
                // 初始时间
                long startTime = System.currentTimeMillis();
                
                // 超时时间
                long waitTimeOut = 10000;
                int count = 1;
                long startTimeTo500 = System.currentTimeMillis();
                while (true)
                {
                    // 当前时间
                    long curTime = System.currentTimeMillis();
                    long waitTime = curTime - startTime;
                    // 直到处理完成或者到达配置时间，则关机
                    if (working.get() == 0)
                    {
                        count = 0;
                    }
                    else
                    {
                        count = 1;
                        startTimeTo500 = curTime;
                    }
                    
                    if (count == 0 && (curTime - startTimeTo500) >= 500)
                    {
                        if (log.isDebugEnable())
                        {
                            log.debug("stop service because working.get() = 0 in 500ms");
                        }
                        break;
                    }
                    
                    if (waitTime >= waitTimeOut)
                    {
                        if (log.isDebugEnable())
                        {
                            log.debug("stop service because waitTime=" + waitTime);
                        }
                        break;
                    }
                    
                }
                
                // Runtime.getRuntime().exit(0); 方案不妥，停机太慢！！
                Runtime run = Runtime.getRuntime();
                //linux根命令目录
                String binsh = "/bin/sh";
                //可配置的执行命令
                String cmd = "jps | grep Bootstrap";
                // 组合命令
                String[] cmds = new String[] {binsh, "-c", cmd};
                
                Process process = null;
                try
                {
                    // 执行命令
                    process = run.exec(cmds);
                    // 获取命令结果集
                    List<String> list = getIOResult(process);
                    // 必能获取到进程id，不会出现空指针异常和角标越界！！
                    String pid = list.get(0).replaceAll("Bootstrap", "").trim();
                    // 强行杀死进程
                    run.exec(new String[] {"kill", "-9", pid});
                }
                catch (Exception e)
                {
                    log.error("kill -9 run.exec error...", e);
                }
            }
            
            private void deleteEtcdInfo() {
                System.out.println("下掉对应的节点");
            }
}

对应的过滤器：

public class WorkingCountFilter implements Filter
{

    private static final DebugLog LOGGER = LogFactory.getDebugLog(WorkingCountFilter.class);

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException
    {
        //初始化
        int workingCount = 0;
        try
        {
            //有请求，则对这台机器的请求进行+1
            workingCount = StartUpServlet.getWorking().incrementAndGet();
            if(LOGGER.isDebugEnable())
            {
                LOGGER.debug("WorkingCountFilter-->>current working incrementAndGet count = " + workingCount);
            }
            chain.doFilter(request, response);
        }
        finally
        {
            //无请求，则对这台机器的请求进行-1
            workingCount = StartUpServlet.getWorking().decrementAndGet();
            if(LOGGER.isDebugEnable())
            {
                LOGGER.debug("WorkingCountFilter-->>current working decrementAndGet count = " + workingCount);
            }
        }
    }
}

总结

当然优雅停机的实现，也不止这些。我们还要求不止优雅的停机，还要优雅的启动。例如服务完全启动前，我们会提供健康检查，包括页面检查，接口检查，缓存检查，数据库检查。来确保服务启动正常。还有一些定时任务的开启，都在初始化的时候调用，都需要优化检验的。所以，相应的工作量还是有点含量的。。