提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其他

当前栏目

Kill - 9 or 15 解析

进程 程序 命令
2023-04-18 15:01:32 时间

一提到“Kill”命令，大家是不是很兴奋，潜意识觉得自己大展宏图之刻即将到来，仿佛自己就是那个黑暗的夜空下拿着长剑的武士，站在高高的山崖顶层，xx一切。。。别，醒醒吧，孩子（大侠）！大家在停止Java进程时（当然，不仅仅是Java，其他应用也同样适用，本文主要针对Java程序进行解析），有没有想过为什么要用kill -9呢？这样操作对吗？

Kill 命令很容易让人产生误解，以为它仅仅就是用来杀死进程的，就像汉语有句话“我喜欢上你”，如果不针对具体的应用场景的话，会出问题的。言归正传，我们来看一下 man page 对它的解释：Kill - send a signal to a process。

从官方的解释可以看出：Kill 的本意是向进程发送信号的命令。当然我们可以向进程发送一个终止运行的信号，此时的 Kill 命令才是名至实归。事实上如果我们不给 Kill 命令传递信号参数，它默认传递终止进程运行的信号给进程！这是 Kill 命令最主要的用法，也是本文要重点解析的内容。

一般情况下，终止一个前台进程使用 Ctrl + C 就可以了。对于一个后台进程大部分就只能需要借助 Kill 命令来实施了。

我们先看个场景，代码功能为使用Timer模拟一个工作线程，该线程重复工作20次，并输出相关信息，简单代码如下所示：

package com.cn.luga.java.lang;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Date: 30-1-21
 * Time: 11:01
 */
public class TestShutdownHook {

    //简单模拟工作
    static Timer timer = new Timer("work-timer");

    //计数工作次数
    static AtomicInteger count = new AtomicInteger(0);

    /**
     * hook线程
     */
    static class CleanWorkThread extends Thread{
        @Override
        public void run() {
            System.out.println("clean some work.");
            timer.cancel();
            try {
                Thread.sleep(2 * 1000);//sleep 2s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //将hook线程添加到运行时环境中去
        Runtime.getRuntime().addShutdownHook(new CleanWorkThread());
        System.out.println("main class start ..... ");
        //简单模拟
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                count.getAndIncrement();
                System.out.println("doing work " + count);
                if (count.get() == 20) {  //工作20次退出
                    System.exit(0);
                }
            }
        }, 0, 2 * 1000);

    }
}

通过上述代码，我们看到上述程序中存在System.exit()方法，意味着，可以借助此方法进行进程的关闭，如果我们强行进行kill -9操作的话，此应用程序会抛异常的，如果是在实际的业务场景，可能会导致数据丢失，业务异常。因为如果直接使用kill -9 pid，JVM注册的钩子不会被调用的。

JDK在1.3之后提供了Java Runtime.addShutdownHook(Thread hook)方法，可以注册一个JVM关闭的钩子，其参数语法如下：

hook -- 一个初始化但尚未启动的线程对象，注册到JVM钩子的运行代码。 IllegalArgumentException -- 如果指定的钩已被注册，或如果它可以判定钩已经运行或已被运行。 IllegalStateException -- 如果虚拟机已经是在关闭的过程中。

SecurityException -- 如果存在安全管理器并且它拒绝的RuntimePermission（“shutdownHooks”）。

我们来看下Kill命令的相关源码，Kill是用户进程发送信号的系统调用，它的系统服务例程为sys_kill。sys_kill其中siginfo结构在includeasm-i386siginfo.h之中，该文件中只有一个include，所以真正的定义在includeasm-genericsiginfo.h中。

sys_kill调用了kill_something_info函数，具体可参考源码所示：

static int kill_something_info(int sig, struct siginfo *info, int pid)
{
    if (!pid) {
        return kill_pg_info(sig, info, process_group(current));
    } else if (pid == -) {
        int retval = , count = ;
        struct task_struct * p;
 
        read_lock(&tasklist_lock);
        for_each_process(p) {
            if (p->pid >  && p->tgid != current->tgid) {
                int err = group_send_sig_info(sig, info, p);
                ++count;
                if (err != -EPERM)
                    retval = err;
            }
        }
        read_unlock(&tasklist_lock);
        return count ? retval : -ESRCH;
    } else if (pid < ) {
        return kill_pg_info(sig, info, -pid);
    } else {
        return kill_proc_info(sig, info, pid);
    }
}

基于kill_something_info，从该函数中，我们可以看到kill系统调用的pid参数的规则及其代表的意义，具体如下：

  • pid>0 将此信号发送给进程ID为pid的进程组
  • pid==0 将此信号发送给同组所有进程
  • pid<0 将此信号发送给组ID为-pid的进程
  • pd==-1 将此信号发送给系统所有的进程

下面我们看下kill_something_info里面的具体函数，在前面的kill_something_info中涉及的kill_pg_info函数，表示将信号发送到一个组，该函数第3个参数为组id。具体如下：

int
kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
{
    int retval;
 
    read_lock(&tasklist_lock);
    retval = __kill_pg_info(sig, info, pgrp);
    read_unlock(&tasklist_lock);
 
    return retval;
}

可以看到，在加锁之后，简单调用了__kill_pg_info函数，具体如下：

int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
{
    struct task_struct *p = NULL;
    int retval, success;
 
    if (pgrp <= )
        return -EINVAL;
 
    success = ;
    retval = -ESRCH;
    do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
        int err = group_send_sig_info(sig, info, p);
        success |= !err;
        retval = err;
    } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
    return success ?  : retval;
}

其中do_each_task_pid宏和while_each_task_pid宏位于includelinuxpid.h之中，同时该文件中有pid_type枚举类型等，和kernelpid.c文件一起，包含着pid的相关内容。再具体的内容这里不再赘述，大家可去查看相关源码。

kill_something_info函数的kill_pg_info所涉及的内容较多，本文暂列出部分。我们接下来看kill_proc_info函数，其加锁之后调用了group_send_sig_info函数，具体如下：

int
kill_proc_info(int sig, struct siginfo *info, pid_t pid)
{
    int error;
    int acquired_tasklist_lock = ;
    struct task_struct *p;
 
    rcu_read_lock();
    if (unlikely(sig_needs_tasklist(sig))) {
        read_lock(&tasklist_lock);
        acquired_tasklist_lock = ;
    }
    p = find_task_by_pid(pid);
    error = -ESRCH;
    if (p)
        error = group_send_sig_info(sig, info, p);
    if (unlikely(acquired_tasklist_lock))
        read_unlock(&tasklist_lock);
    rcu_read_unlock();
    return error;
}

关于到底是Kill -9 还是Kill -15，以下为简要对比解析：

[administrator@JavaLangOutOfMemory ~ ]% Kill -15

被称为优雅的退出。当使用kill -15时，系统会发送一个SIGTERM的信号给对应的程序。当程序接收到该信号后，具体要如何处理是应用程序自己可以决定的。可以选择：

1、立即停止程序

2、释放响应资源后停止程序

3、忽略该信号，继续执行程序

因为kill -15信号只是通知对应的进程要进行"安全、干净的退出"，程序接到信号之后，退出前一般会进行一些"准备工作"，如资源释放、临时文件清理等等，如果准备工作做完了，再进行程序的终止。但是，如果在"准备工作"进行过程中，遇到阻塞或者其他问题导致无法成功，那么应用程序可以选择忽略该终止信号。

这也就是为什么我们有的时候使用kill命令是没办法"杀死"应用的原因，因为默认的kill信号是SIGTERM（15），而SIGTERM（15）的信号是可以被阻塞和忽略的。

大部分程序接收到SIGTERM信号后，会先释放自己的资源，然后在停止。但是也有程序可以在接受到信号量后，做一些其他的事情，并且这些事情是可以配置的。如果程序正在等待IO，可能就不会立马做出相应，或者等待其他项目的响应。

[administrator@JavaLangOutOfMemory ~ ]% Kill -9

与kill -15相比，kill -9就相对强硬一点，系统会发出SIGKILL信号，他要求接收到该信号的程序应该立即结束运行，不能被阻塞或者忽略。

所以，相比于kill -15命令，kill -9在执行时，应用程序是没有时间进行"准备工作"的，所以这通常会带来一些副作用，数据丢失或者终端无法恢复到正常状态等。

那么在实际的业务场景中，如何停掉Java应用进程呢？下面给出些建议：

1、尽可能用应用框架提供的服务操作命令，例如，针对Tomcat Web容器，我们可以编写脚本触发其shutdown.sh命令。

2、借助Shell调用ShutdownHook方法，如果无法判断直接Kill -9对杀死进程有没有影响的条件下。

3、若此应用服务进程调用较为单一，在合适的时刻，优先使用Kill -15，实在不行再考虑Kill -9。

相关文章