The right way to kill a process in Java

Question

What's the best way to kill a process in Java ?

Get the PID and then killing it with Runtime.exec() ?

Use destroyForcibly() ?

What's the difference between these two methods, and is there any others solutions ?

Sulemasulf

Is this your own process or another process? – Torsion

is it a java process or any process ? – Gustavo

It was for an external non-Java process, but thanks for the both way Shitsu – Sulemasulf

Answer 1

If the process you want to kill has been started by your application

Then you probably have a reference to it (ProcessBuilder.start() or Runtime.exec() both return a reference). In this case, you can simply call p.destroy(). I think this is the cleanest way (but be careful: sub-processes started by p may stay alive, check Process.destroy does not kill multiple child processes for more info).

The destroyForcibly should only be used if destroy() failed after a certain timeout. In a nutshell

1. terminate process with destroy()
2. allow process to exit gracefully with reasonable timeout
3. kill it with destroyForcibly() if process is still alive

---

If the process you want to kill is external

Then you don't have much choice: you need to pass through the OS API (Runtime.exec). On Windows, the program to call will be taskkill.exe, while on Mac and Linux you can try kill.

---

Have a look at Support for Process.destroyForcibly() and .isAlive() from Java 8 and Killing a process using Java and Code a Simple Java App to Kill Any Process After a Specified Time for more info.

Gustavo

Thanks a lot for the explanations ! This is definitely what I was looking for – Sulemasulf

Got a question, let's say I need to create a new Runtime.exec() reference to an already started one. How would I do that. Which I need to do for destroying it? – Misconduct

Answer 2

If you're trying to kill the main process your java code started, I'd suggest using System.exit(). The benefits are explained here: when should we call system exit in java.

Essentially, System.exit() will run shutdown hooks that will make sure any dependent non-daemon processes that may not have completed their work are killed before your process is killed. This is the clean way to do it.

If the process is not yours, you will have to rely on the Operating System to do this work for you as explained in this answer: Killing a Process Using Java

In that case your suggestion of Runtime.exec() a kill on *nix would be a decent way to go.

Now as for destroyForcibly(), you're typically going to call that on a child process spawned by your java code that was presumably started with the process api's ProcessBuilder.start() or Runtime.exec()

Sciurine

Answer 3

Java 9 introduced ProcessHandle that exposes .destroy() and .destroyForcibly() methods.

TL;DR:

If you know the process ID (pid) then use ".of":

ProcessHandle.of(pid).destroy();

Otherwise take the following steps:

1. list all currently running processes with ProcessHandle.allProcesses()
2. inspect them with .info()
3. use one of destroy methods mentioned above.

Talton

Answer 4

the one that worked for me is System.exit(0); it's work's well because it closes all still running processes and components

Chaotic

Answer 5

In java 8 source code

public Process destroyForcibly() {
    destroy();
    return this;
}

I just want to say that the destroyForcibly is equal to the destroy in Java 8.
So you should try to kill the process by pid if process is still alive after you called the destroy method. You can easily get the pid if you are on java 9+,just call Process.pid() method.

Forepleasure

Some explanation would greatly improve the quality of the answer and help other users who may encounter similar problems in the future Please take some time to read the help page stackoverflow.com/help/how-to-answer – Slump

While this code snippet may solve the question, including an explanation really helps to improve the quality of your post. Remember that you are answering the question for readers in the future, and those people might not know the reasons for your code suggestion. – Turkish

If you dig a bit deeper, you might find that actually there is a subclass implementing destroyForcibly() in a different way. For Unices, looks like it's been so since Java 1.5 (look for ProcessImpl, which actually ends up calling native code). So it is not equivalent to a plain destroy(). – Semiporcelain

Why is there "destroyForcibly" anyway, if it's the same? Is there any JVM that it's not the same? – Reiners

The source code you saw is just the implementation of the base class. The actual Process class is different, the destroyForcibly call a native call which send signal SIGKILL. – Catie