一提到“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结构在include\asm-i386\siginfo.h之中，该文件中只有一个include，所以真正的定义在include\asm-generic\siginfo.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宏位于include\linux\pid.h之中，同时该文件中有pid_type枚举类型等，和kernel\pid.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。
- EOF -
如果您喜欢本文，欢迎点赞、收藏、留言，或者点击右下角，把文章分享给你的朋友们～～～
“路，在自己脚下～”
