Points To Remember

1. You cannot destroy or terminate the current process not even forcefully.
2. You can destroy a process by using the methods destroy() or forcefully using destroyForcibly().

Read More

• Java 9 Feature
• List all processes running on the OS
• Get the information of the current process
• Start a new Process and get its Process Id
• How to get Process Information from Process Id
• Destroy a running process

Destroy a Process

There are two methods in interface ProcessHandle that can be used to destroy a process.

1. destroy() - to destroy a process noramally
2. destroyForcibly() - to destroy a process forcefully. However the process may not be terminatted instantly since operating system access controls may prevent the process from being killed thus resulting in case where isAlive() method may return true for a brief period after destroyForcibly() is called.

In the example below we will first create a process and then kill it forcefully.

import java.io.IOException;
import java.lang.ProcessHandle;
import java.lang.Process;

/**
 * @author ekiras
 */
public class DestroyProcess {

    public static void main(String[] args) throws InterruptedException {
        try {
            ProcessHandle processHandle = startProcess("tail -F /dev/null").toHandle();
            printProcessInfo(processHandle);
            destroyProcess(processHandle);
            Thread.sleep(1000);
            printProcessInfo(processHandle);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---Process Info---");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

    public static void destroyProcess(ProcessHandle process) throws IllegalStateException{
        System.out.println("Going to destroy Process with id :: " + process.getPid());
        process.destroyForcibly();
    }

    public static Process startProcess(String command) throws IOException {
        System.out.println("Start Process :");
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(command);
        return process;
    }

}

In the above code we have used Thread.sleep(1000); to wait for the process to be terminated since operating system access controls may prevent the process from being killed and isAlive() method may return true for a brief period of time. This code will return the following output.

Start Process : 
---Process Info---
 Process Id :: 161
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /usr/bin/tail, args: [-F, /dev/null], startTime: Optional[2016-11-28T18:52:48.540Z], totalTime: Optional[PT0S]]
Going to destroy Process with id :: 161
---Process Info---
 Process Id :: 161
 Process isAlive() :: false
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: []

Trying to Destroy Current Process

As already stated, you cannot destroy the current process even forcefully. Doing so will throw IllegalStateException. Lets take a look at the exxample.

import java.io.IOException;
import java.lang.ProcessHandle;

/**
 * @author ekiras
 */
public class DestroyCurrentProcess {


    public static void main(String[] args) throws IOException {
        currentProcessInfo();
    }

    public static void currentProcessInfo(){
        System.out.println("Current Process : ");
        ProcessHandle process = ProcessHandle.current();
        printProcessInfo(process);
        destroyProcess(process);
    }


    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

    public static void destroyProcess(ProcessHandle process) throws IllegalStateException{
        System.out.println("Going to destroy Process with id :: " + process.getPid());
        process.destroyForcibly();
    }

}

This will throw the error is shown below.

Current Process : 
---------------------------------------------------------
 Process Id :: 84
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /opt/jdk-9/bin/java, args: [DestroyCurrentProcess], startTime: Optional[2016-11-28T18:45:24.700Z], totalTime: Optional[PT0.34S]]
Going to destroy Process with id :: 84
Exception in thread "main" java.lang.IllegalStateException: destroy of current process not allowed
    at java.base/java.lang.ProcessHandleImpl.destroyProcess(ProcessHandleImpl.java:308)
    at java.base/java.lang.ProcessHandleImpl.destroyForcibly(ProcessHandleImpl.java:331)
    at DestroyCurrentProcess.destroyProcess(DestroyCurrentProcess.java:34)
    at DestroyCurrentProcess.currentProcessInfo(DestroyCurrentProcess.java:18)
    at DestroyCurrentProcess.main(DestroyCurrentProcess.java:11)

Points to Remember

1. You need to run this code with Java 1.9
2. ProcessHandle.of(Long processId) method will return an object of Optional<ProcessHandle>.
3. Optional is a class introduced in java 8 which is a container object which may or may not contain a non-null value. It has methods boolean isPresent() which returns true if a value is present else returns false. T get() method returns the object if present or else throws NoSuchElementException.

Read More

• Java 9 Feature
• List all processes running on the OS
• Get the information of the current process
• Start a new Process and get its Process Id
• How to get Process Information from Process Id
• Destroy a running process

Get Process Information from Process Id

If we have the process id of a process, then we can get the information about the process as shown in the following code.

import java.io.IOException;
import java.lang.ProcessHandle;
import java.lang.Process;

/**
 * @author ekiras
 */
public class DestroyProcess {

    public static void main(String[] args) throws InterruptedException {
        try {
            ProcessHandle processHandle = startProcess("tail -F /dev/null").toHandle();
            printProcessInfo(processHandle);
            destroyProcess(processHandle);
            Thread.sleep(1000);
            printProcessInfo(processHandle);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---Process Info---");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

    public static void destroyProcess(ProcessHandle process) throws IllegalStateException{
        System.out.println("Going to destroy Process with id :: " + process.getPid());
        process.destroy();
    }

    public static Process startProcess(String command) throws IOException {
        System.out.println("Start Process :");
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(command);
        return process;
    }

}

We have a process running with the process id 678. Read How to start a new Process. When we run the above code with a valid process id it will result in the following output.

> java GetProcessById 678
---Process Info---
 Process Id :: 678
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /usr/bin/tail, args: [-f, /dev/null], startTime: Optional[2016-11-14T08:36:02.310Z], totalTime: Optional[PT0S]]

When we run the above code with an invalid process id, we will get the following output.

>  java GetProcessById 6785
 No process found by Process Id :: 6785

Points to Remember

1. This post used Java 1.9 since ProcessHandle was introduced in Java 1.9.

Read More

• Java 9 Feature
• List all processes running on the OS
• Get the information of the current process
• Start a new Process and get its Process Id
• How to get Process Information from Process Id
• Destroy a running process

Get the Current Process Information.

In this example we will try to get information about the current process. For this we will use the m

import java.io.IOException;

/**
 * @author ekiras
 */
public class StartProcess {

    public static void main(String[] args) {
        try {
            Process process = startProcess("tail -F /dev/null");
            printProcessInfo(process.toHandle());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---Process Info---");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

    public static Process startProcess(String command) throws IOException {
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(command);
        return process;
    }

}

When we run the above code, it will return the following output.

---Process Info---
 Process Id :: 1865
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /usr/bin/tail, args: [-F, /dev/null], startTime: Optional[2016-11-16T12:40:10.460Z], totalTime: Optional[PT0S]]

Points to Remember

1. Java 9 introduced the new Process Api in java.lang package.
2. ProcessHandle interface can be used to perform operations with processes like start, destroy, list processes.

Read More

• Get the information of the current process
• Create a new process and then terminate it
• Terminating the current process
• Destroy a process forcefully
• Get children of a process

Get the Current Process Information.

In this example we will try to get information about the current process. For this we will use the method ProcessHandle.current() method, this will return the object ProcessHandle which can be used to get the information of the process.

import java.io.IOException;
import java.lang.ProcessHandle;

/**
 * @author ekiras
 */
public class CurrentProcess {

    public static void main(String[] args) throws IOException {
        currentProcessInfo();
    }

    public static void currentProcessInfo(){
        System.out.println("Current Process : ");
        ProcessHandle process = ProcessHandle.current();
        printProcessInfo(process);
    }


    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

}

The above code will produce the following output on console.

Current Process : 
---------------------------------------------------------
 Process Id :: 551
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /opt/jdk-9/bin/java, args: [CurrentProcess], startTime: Optional[2016-11-14T07:45:33.440Z], totalTime: Optional[PT0.24S]]

Points to Remember

1. Java 9 introduced the new Process Api in java.lang package.
2. ProcessHandle interface can be used to perform operations with processes like start, destroy, list processes.

Read More

• Java 9 Feature
• List all processes running on the OS
• Get the information of the current process
• Start a new Process and get its Process Id
• How to get Process Information from Process Id
• Destroy a running process

List all Processes running on the OS.

To get all the processes running on the OS you can use the static method allProcesses() of the ProcessHandle, this will return a Stream<ProcessHandle> stream of process handles which can be used to get information about each process. The below example shows how we can list all the running processes.

import java.lang.ProcessHandle;
import java.util.stream.Stream;

/**
 * @author ekiras
 */
public class ListAllProcesses {

    public static void main(String[] args){
        allProcesses();
    }

    public static void allProcesses() {
        System.out.println("Process list:");
        Stream<ProcessHandle> processStream = ProcessHandle.allProcesses();
        processStream.forEach(e -> printProcessInfo(e));
    }

    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

}

The above code will produce the following output on console.

Process list:
---------------------------------------------------------
 Process Id :: 1
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /bin/bash, startTime: Optional[2016-11-14T05:24:57.150Z], totalTime: Optional[PT0.02S]]
---------------------------------------------------------
 Process Id :: 15
 Process isAlive() :: true
 Process children :: 1
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /bin/bash, startTime: Optional[2016-11-14T05:25:06.670Z], totalTime: Optional[PT0.08S]]
---------------------------------------------------------
 Process Id :: 449
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /opt/jdk-9/bin/java, args: [ListAllProcesses], startTime: Optional[2016-11-14T07:38:41.240Z], totalTime: Optional[PT0.35S]]

Introduction to Java 9 Process Api

The New Java 9 Processes API will help provide

1. Identifies the processess
2. Control of Native processes
3. Monitoring of processes
4. List Children of processess
5. Start a new Process
6. Destroy a running process
7. Access to the process input,output and error streams.
8. On Exit Handle when a process is destroyed or completed.

Testing Process API operations

In this post java program we are testing the following operations

1. List all processess running in the OS.
2. Print the information of the current process.
3. Create a new process and then terminate it.
4. Do some action when the process is destroyed or completed.
5. Try to terminate the current process.
6. Destroy a process forcefully
7. Get children of a process.

List all Processess

ProcessHandle.allProcesses() is a static method in ProcessHandle interface that returns Stream<ProcessHandle> object. We will iterate this stream to print the information of all the processess running.

package com.ekiras.java9.processapi;


import java.lang.ProcessHandle;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * @author ekiras
 */
public class ListAllProcesses {

    public static void main(String[] args){
        allProcesses();
    }

    public static void allProcesses() {
        System.out.println("Process list:");
        Stream<ProcessHandle> processStream = ProcessHandle.allProcesses();
        processStream.forEach(e -> printProcessInfo(e));
    }

    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("------------------------------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

}

The above code will produce the following output on console.

Process list:
---------------------------------------------------------
 Process Id :: 1
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /bin/bash, startTime: Optional[2016-11-14T05:24:57.150Z], totalTime: Optional[PT0.02S]]
---------------------------------------------------------
 Process Id :: 15
 Process isAlive() :: true
 Process children :: 1
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /bin/bash, startTime: Optional[2016-11-14T05:25:06.670Z], totalTime: Optional[PT0.08S]]
---------------------------------------------------------
 Process Id :: 449
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /opt/jdk-9/bin/java, args: [ListAllProcesses], startTime: Optional[2016-11-14T07:38:41.240Z], totalTime: Optional[PT0.35S]]

Current Process Information

In this example we will try to get information about the current process. For this we will use the method ProcessHandle.current() method, this will return the object ProcessHandle which can be used to get the information of the process.

import java.io.IOException;
import java.lang.ProcessHandle;

/**
 * @author ekiras
 */
public class CurrentProcess {

    public static void main(String[] args) throws IOException {
        currentProcessInfo();
    }

    public static void currentProcessInfo(){
        System.out.println("Current Process : ");
        ProcessHandle process = ProcessHandle.current();
        printProcessInfo(process);
    }


    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

}

The above code will produce the following output on console.

Current Process : 
---------------------------------------------------------
 Process Id :: 551
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /opt/jdk-9/bin/java, args: [CurrentProcess], startTime: Optional[2016-11-14T07:45:33.440Z], totalTime: Optional[PT0.24S]]

Terminating a Process

In this example we will terminate/destroy a running process using destroy() method in the ProcessHandle interface.

To test this we have started a process to run in background. e.g

tail -F /dev/null &;

Now we will destroy this process through our code.

import java.io.IOException;
import java.lang.ProcessHandle;
import java.lang.Process;

/**
 * @author ekiras
 */
public class DestroyProcess {

    public static void main(String[] args) throws InterruptedException {
        try {
            ProcessHandle processHandle = startProcess("tail -F /dev/null").toHandle();
            printProcessInfo(processHandle);
            destroyProcess(processHandle);
            Thread.sleep(1000);
            printProcessInfo(processHandle);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

    public static void destroyProcess(ProcessHandle process) throws IllegalStateException{
        System.out.println("Going to destroy Process with id :: " + process.getPid());
        process.destroy();
    }

    public static Process startProcess(String command) throws IOException {
        System.out.println("Start Process :");
        Runtime runtime = Runtime.getRuntime();
        Process process = runtime.exec(command);
        return process;
    }

}

The above code will produce the following output on console.

Start Process : 
---------------------------------------------------------
 Process Id :: 1259
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /usr/bin/tail, args: [-F, /dev/null], startTime: Optional[2016-11-14T15:52:01.670Z], totalTime: Optional[PT0S]]
Going to destroy Process with id :: 1259
---------------------------------------------------------
 Process Id :: 1259
 Process isAlive() :: false
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: []

Terminating Current Process

We cannot destroy the current Process trying to destroy the current process will throw IllegalStateException. In this example we will try to destroy/terminate the current process to see what happens when we try to destroy the current process.

import java.io.IOException;
import java.lang.ProcessHandle;

/**
 * @author ekiras
 */
public class DestroyCurrentProcess {


    public static void main(String[] args) throws IOException {
        currentProcessInfo();
    }

    public static void currentProcessInfo(){
        System.out.println("Current Process : ");
        ProcessHandle process = ProcessHandle.current();
        printProcessInfo(process);
        destroyProcess(process);
    }


    public static void printProcessInfo(ProcessHandle processHandle){
        System.out.println("---------------------------------------------------------");
        System.out.println(" Process Id :: " + processHandle.getPid());
        System.out.println(" Process isAlive() :: " + processHandle.isAlive());
        System.out.println(" Process children :: " + processHandle.children().count());
        System.out.println(" Process supportsNormalTermination() :: " + processHandle.supportsNormalTermination());
        System.out.println(" Process Info :: " + processHandle.info().toString());

    }

    public static void destroyProcess(ProcessHandle process) throws IllegalStateException{
        System.out.println("Going to destroy Process with id :: " + process.getPid());
        process.destroy();
    }

}

The above code will produce the following output on console.

Current Process : 
---------------------------------------------------------
 Process Id :: 653
 Process isAlive() :: true
 Process children :: 0
 Process supportsNormalTermination() :: true
 Process Info :: [user: Optional[root], cmd: /opt/jdk-9/bin/java, args: [DestroyCurrentProcess], startTime: Optional[2016-11-14T08:32:28.640Z], totalTime: Optional[PT0.32S]]
Going to destroy Process with id :: 653
Exception in thread "main" java.lang.IllegalStateException: destroy of current process not allowed
    at java.base/java.lang.ProcessHandleImpl.destroyProcess(ProcessHandleImpl.java:308)
    at java.base/java.lang.ProcessHandleImpl.destroy(ProcessHandleImpl.java:326)
    at DestroyCurrentProcess.destroyProcess(DestroyCurrentProcess.java:34)
    at DestroyCurrentProcess.currentProcessInfo(DestroyCurrentProcess.java:18)
    at DestroyCurrentProcess.main(DestroyCurrentProcess.java:11)