Java : Process with Examples
Last Modified : March 26, 2023 Published : March 7, 2023
Process (Java SE 19 & JDK 19) API Examples.
You will find code examples on most Process methods.
Summary
Process provides control of native processes started by ProcessBuilder.start and Runtime.exec. The class provides methods for performing input from the process, performing output to the process, waiting for the process to complete, checking the exit status of the process, and destroying (killing) the process.
Please see also : ProcessBuilder
public class Child {
public static void main(String[] args) {
System.out.println(" TEST 1");
System.out.println(" TEST 2");
System.out.println(" TEST 3");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
try (final var reader = process.inputReader()) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
// TEST 1
// TEST 2
// TEST 3
//waitFor : 0
//main : end
Constructors
Process ()
Default constructor for Process.
This class is abstract. I think it's rare to create a subclass of this class. Therefore, the code example is omitted.
Methods
Stream<ProcessHandle> children ()
Returns a snapshot of the direct children of the process.
public class Parent {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("parent : start");
final var processA = new ProcessBuilder("java", "ChildA").inheritIO().start();
System.out.println(" child A pid = " + processA.pid());
final var processB = new ProcessBuilder("java", "ChildB").inheritIO().start();
System.out.println(" child B pid = " + processB.pid());
processA.waitFor();
processB.waitFor();
System.out.println("parent : end");
}
}
public class ChildA {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
}
}
public class ChildB {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Parent").inheritIO().start();
TimeUnit.SECONDS.sleep(1);
System.out.println("-- children --");
final var stream = process.children();
stream.forEach(processHandle -> {
System.out.println("process handle : " + processHandle);
});
System.out.println("--------------");
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//parent : start
// child A pid = 7936
// child B pid = 22724
//-- children --
//process handle : 7936
//process handle : 22724
//--------------
//parent : end
//waitFor : 0
//main : end
Stream<ProcessHandle> descendants ()
Returns a snapshot of the descendants of the process.
public class Parent {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("parent : start");
final var process = new ProcessBuilder("java", "Child").inheritIO().start();
System.out.println(" child pid = " + process.pid());
process.waitFor();
System.out.println("parent : end");
}
}
public class Child {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("child : start");
final var processA = new ProcessBuilder("java", "DescendantA").inheritIO().start();
System.out.println(" descendant A pid = " + processA.pid());
final var processB = new ProcessBuilder("java", "DescendantB").inheritIO().start();
System.out.println(" descendant B pid = " + processB.pid());
processA.waitFor();
processB.waitFor();
System.out.println("child : end");
}
}
public class DescendantA {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
}
}
public class DescendantB {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Parent").inheritIO().start();
TimeUnit.SECONDS.sleep(1);
System.out.println("-- descendants --");
final var stream = process.descendants();
stream.forEach(processHandle -> {
System.out.println("process handle : " + processHandle);
});
System.out.println("--------------");
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//parent : start
// child pid = 21596
//child : start
// descendant A pid = 3456
// descendant B pid = 21224
//-- descendants --
//process handle : 21596
//process handle : 3456
//process handle : 21224
//--------------
//child : end
//parent : end
//waitFor : 0
//main : end
abstract void destroy ()
Kills the process.
public class Child {
public static void main(String[] args) throws InterruptedException {
System.out.println("child : start");
TimeUnit.SECONDS.sleep(5);
System.out.println("child : end");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").inheritIO().start();
TimeUnit.SECONDS.sleep(1);
if (args.length == 1 && "destroy".equals(args[0])) {
System.out.println("Destroy!");
process.destroy();
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//child : start
//child : end
//waitFor : 0
//main : end
//
//> java Main destroy
//main : start
//child : start
//Destroy!
//waitFor : 1
//main : end
Process destroyForcibly ()
Kills the process forcibly.
public class Child {
public static void main(String[] args) throws InterruptedException {
System.out.println("child : start");
TimeUnit.SECONDS.sleep(5);
System.out.println("child : end");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").inheritIO().start();
System.out.println("process : " + process);
TimeUnit.SECONDS.sleep(1);
if (args.length == 1 && "destroy".equals(args[0])) {
System.out.println("destroy : " + process.destroyForcibly());
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//process : Process[pid=23168, exitValue="not exited"]
//child : start
//child : end
//waitFor : 0
//main : end
//
//> java Main destroy
//main : start
//process : Process[pid=17924, exitValue="not exited"]
//child : start
//destroy : Process[pid=17924, exitValue=1]
//waitFor : 1
//main : end
final BufferedReader errorReader ()
Returns a BufferedReader connected to the standard error of the process.
public class Child {
public static void main(String[] args) {
System.out.println(" OUT 1");
System.err.println(" ERR 1");
System.out.println(" OUT 2");
System.err.println(" ERR 2");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
try (final var reader = process.errorReader()) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
// ERR 1
// ERR 2
//waitFor : 0
//main : end
final BufferedReader errorReader (Charset charset)
Returns a BufferedReader connected to the standard error of this process using a Charset.
public class Child {
public static void main(String[] args) {
System.err.println("stderr.encoding = " + System.getProperty("stderr.encoding"));
System.err.println("ERR : ○△×");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var charset = Charset.forName("UTF-32");
final var process = new ProcessBuilder("java", "-Dstderr.encoding=UTF-32", "Child").start();
try (final var reader = process.errorReader(charset)) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//stderr.encoding = UTF-32
//ERR : ○△×
//waitFor : 0
//main : end
abstract int exitValue ()
Returns the exit value for the process.
public class ChildA {
public static void main(String[] args) throws InterruptedException {
System.out.println("child A : start");
TimeUnit.SECONDS.sleep(5);
System.out.println("child A : end");
}
}
public class ChildB {
public static void main(String[] args) throws InterruptedException {
System.out.println("child B : start");
TimeUnit.SECONDS.sleep(5);
System.out.println("child B : end");
System.exit(-100);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
System.out.println("-- process A --");
final var processA = new ProcessBuilder("java", "ChildA").inheritIO().start();
System.out.println("waitFor : " + processA.waitFor());
System.out.println("exit value : " + processA.exitValue());
System.out.println("-- process B --");
final var processB = new ProcessBuilder("java", "ChildB").inheritIO().start();
System.out.println("waitFor : " + processB.waitFor());
System.out.println("exit value : " + processB.exitValue());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//-- process A --
//child A : start
//child A : end
//waitFor : 0
//exit value : 0
//-- process B --
//child B : start
//child B : end
//waitFor : -100
//exit value : -100
//main : end
abstract InputStream getErrorStream ()
Returns the input stream connected to the error output of the process.
public class Child {
public static void main(String[] args) {
System.out.println(" OUT 1");
System.err.println(" ERR 1");
System.out.println(" OUT 2");
System.err.println(" ERR 2");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
try (final var reader = new BufferedReader(
new InputStreamReader(process.getErrorStream()))) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
// ERR 1
// ERR 2
//waitFor : 0
//main : end
abstract InputStream getInputStream ()
Returns the input stream connected to the normal output of the process.
public class Child {
public static void main(String[] args) {
System.out.println(" OUT 1");
System.err.println(" ERR 1");
System.out.println(" OUT 2");
System.err.println(" ERR 2");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
try (final var reader = new BufferedReader(
new InputStreamReader(process.getInputStream()))) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
// OUT 1
// OUT 2
//waitFor : 0
//main : end
abstract OutputStream getOutputStream ()
Returns the output stream connected to the normal input of the process.
public class Child {
public static void main(String[] args) {
System.out.println("child : start");
final var sc = new Scanner(System.in);
while (sc.hasNext()) {
final var next = sc.next();
if ("quit".equals(next)) {
System.out.println(" Quit!");
break;
}
System.out.println(" next : " + next);
}
System.out.println("child : end");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child")
.redirectOutput(ProcessBuilder.Redirect.INHERIT).start();
try (final var writer = new BufferedWriter(
new OutputStreamWriter(process.getOutputStream()))) {
writer.write("abcd");
writer.newLine();
writer.write("1234");
writer.newLine();
writer.write("quit");
writer.newLine();
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//child : start
// next : abcd
// next : 1234
// Quit!
//child : end
//waitFor : 0
//main : end
ProcessHandle.Info info ()
Returns a snapshot of information about the process.
public class Child {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
TimeUnit.SECONDS.sleep(1);
final var info = process.info();
System.out.println("user : " + info.user());
System.out.println("total cpu time : " + info.totalCpuDuration());
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//user : Optional[MY-PC\xxxx]
//total cpu time : Optional[PT0.140625S]
//waitFor : 0
//main : end
final BufferedReader inputReader ()
Returns a BufferedReader connected to the standard output of the process.
public class Child {
public static void main(String[] args) {
System.out.println(" OUT 1");
System.err.println(" ERR 1");
System.out.println(" OUT 2");
System.err.println(" ERR 2");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
try (final var reader = process.inputReader()) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
// OUT 1
// OUT 2
//waitFor : 0
//main : end
final BufferedReader inputReader (Charset charset)
Returns a BufferedReader connected to the standard output of this process using a Charset.
public class Child {
public static void main(String[] args) {
System.out.println("stdout.encoding = " + System.getProperty("stdout.encoding"));
System.out.println("OUT : ○△×");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var charset = Charset.forName("UTF-32");
final var process = new ProcessBuilder("java", "-Dstdout.encoding=UTF-32", "Child").start();
try (final var reader = process.inputReader(charset)) {
reader.lines().forEach(System.out::println);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//stdout.encoding = UTF-32
//OUT : ○△×
//waitFor : 0
//main : end
boolean isAlive ()
Tests whether the process represented by this Process is alive.
public class Child {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(5);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
TimeUnit.SECONDS.sleep(1);
System.out.println("isAlive : " + process.isAlive());
System.out.println("waitFor : " + process.waitFor());
System.out.println("isAlive : " + process.isAlive());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//isAlive : true
//waitFor : 0
//isAlive : false
//main : end
CompletableFuture<Process> onExit ()
Returns a CompletableFuture<Process> for the termination of the Process.
public class Child {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(5);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").start();
System.out.println("process : " + process);
final var ret = process.onExit().thenApply(p -> {
System.out.println("pid : " + p.pid());
System.out.println("isAlive : " + p.isAlive());
System.out.println("exitValue : " + p.exitValue());
return p;
}).get();
System.out.println("ret : " + ret);
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//process : Process[pid=6116, exitValue="not exited"]
//pid : 6116
//isAlive : false
//exitValue : 0
//ret : Process[pid=6116, exitValue=0]
//main : end
final BufferedWriter outputWriter ()
Returns a BufferedWriter connected to the normal input of the process using the native encoding.
public class Child {
public static void main(String[] args) {
System.out.println("child : start");
final var sc = new Scanner(System.in);
while (sc.hasNext()) {
final var next = sc.next();
if ("quit".equals(next)) {
System.out.println(" Quit!");
break;
}
System.out.println(" next : " + next);
}
System.out.println("child : end");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child")
.redirectOutput(ProcessBuilder.Redirect.INHERIT).start();
try (final var writer = process.outputWriter()) {
writer.write("abcd");
writer.newLine();
writer.write("1234");
writer.newLine();
writer.write("quit");
writer.newLine();
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//child : start
// next : abcd
// next : 1234
// Quit!
//child : end
//waitFor : 0
//main : end
final BufferedWriter outputWriter (Charset charset)
Returns a BufferedWriter connected to the normal input of the process using a Charset.
public class Child {
public static void main(String[] args) throws IOException {
System.out.println("child : start");
final var bytes = System.in.readAllBytes();
System.out.println(" bytes : " + Arrays.toString(bytes));
System.out.println("child : end");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var str = "○△×";
final var charset = Charset.forName("UTF-32");
System.out.println("UTF-8 : " + Arrays.toString(str.getBytes()));
System.out.println("UTF-32 : " + Arrays.toString(str.getBytes(charset)));
final var process = new ProcessBuilder("java", "Child")
.redirectOutput(ProcessBuilder.Redirect.INHERIT).start();
try (final var writer = process.outputWriter(charset)) {
writer.write(str);
}
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//UTF-8 : [-30, -105, -117, -30, -106, -77, -61, -105]
//UTF-32 : [0, 0, 37, -53, 0, 0, 37, -77, 0, 0, 0, -41]
//child : start
// bytes : [0, 0, 37, -53, 0, 0, 37, -77, 0, 0, 0, -41]
//child : end
//waitFor : 0
//main : end
long pid ()
Returns the native process ID of the process.
public class Child {
public static void main(String[] args) {
System.out.println("child : start");
System.out.println(" pid : " + ProcessHandle.current().pid());
System.out.println("child : end");
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var process = new ProcessBuilder("java", "Child").inheritIO().start();
System.out.println("pid : " + process.pid());
System.out.println("waitFor : " + process.waitFor());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//pid : 16868
//child : start
// pid : 16868
//child : end
//waitFor : 0
//main : end
boolean supportsNormalTermination ()
Returns true if the implementation of destroy() is to normally terminate the process, Returns false if the implementation of destroy forcibly and immediately terminates the process.
final var builder = new ProcessBuilder("java", "--version");
final var process = builder.start();
System.out.println(process.supportsNormalTermination()); // false
final var ret = process.waitFor();
System.out.println(ret); // 0
ProcessHandle toHandle ()
Returns a ProcessHandle for the Process.
final var builder = new ProcessBuilder("java", "--version");
final var process = builder.start();
System.out.println(process); // Process[pid=9820, exitValue="not exited"]
final var handle = process.toHandle();
System.out.println(handle); // 9820
final var ret = process.waitFor();
System.out.println(ret); // 0
abstract int waitFor ()
Causes the current thread to wait, if necessary, until the process represented by this Process object has terminated.
Please see exitValue().
boolean waitFor (long timeout, TimeUnit unit)
Causes the current thread to wait, if necessary, until the process represented by this Process object has terminated, or the specified waiting time elapses.
public class Child {
public static void main(String[] args) throws InterruptedException {
TimeUnit.SECONDS.sleep(5);
}
}
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("main : start");
final var startTime = System.nanoTime();
final var process = new ProcessBuilder("java", "Child").start();
System.out.println("waitFor : " + process.waitFor(2, TimeUnit.SECONDS));
System.out.println((System.nanoTime() - startTime) / 1000000000.0 + " sec.");
System.out.println("isAlive : " + process.isAlive());
System.out.println("----");
System.out.println("waitFor : " + process.waitFor(10, TimeUnit.SECONDS));
System.out.println((System.nanoTime() - startTime) / 1000000000.0 + " sec.");
System.out.println("isAlive : " + process.isAlive());
System.out.println("main : end");
}
}
// Result
// ↓
//> java Main
//main : start
//waitFor : false
//2.0467682 sec.
//isAlive : true
//----
//waitFor : true
//5.1817541 sec.
//isAlive : false
//main : end