8354872: Clarify java.lang.Process resource cleanup

Reviewed-by: jpai

Author: Roger Riggs

src/java.base/share/classes/java/lang/Process.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1995, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -41,7 +41,7 @@
 
 /**
  * {@code Process} provides control of native processes started by
- * ProcessBuilder.start and Runtime.exec.
+ * {@code ProcessBuilder.start} and {@code 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)
@@ -78,10 +78,6 @@
  * process I/O can also be redirected</a>
  * using methods of the {@link ProcessBuilder} class.
  *
- * <p>The process is not killed when there are no more references to
- * the {@code Process} object, but rather the process
- * continues executing asynchronously.
- *
  * <p>There is no requirement that the process represented by a {@code
  * Process} object execute asynchronously or concurrently with respect
  * to the Java process that owns the {@code Process} object.
@@ -98,6 +94,49 @@
  * Delegating to the underlying Process or ProcessHandle is typically
  * easiest and most efficient.
  *
+ * <h2>Resource Usage</h2>
+ * {@linkplain ProcessBuilder#start() Starting a process} uses resources in both the invoking process and the invoked
+ * process and for the communication streams between them.
+ * The resources to control the process and for communication between the processes are retained
+ * until there are no longer any references to the Process or the input, error, and output streams
+ * or readers, or they have been closed.
+ *
+ * <p>The process is not killed when there are no more references to the {@code Process} object,
+ * but rather the process continues executing asynchronously.
+ * The process implementation closes file descriptors and handles for streams
+ * that are no longer referenced to prevent leaking operating system resources.
+ * Processes that have terminated or been terminated are monitored and their resources released.
+ *
+ * <p>Streams should be {@code closed} when they are no longer needed, to avoid delaying
+ * releasing the operating system resources.
+ * {@code Try-with-resources} can be used to open and close the streams.
+ * <p>For example, to capture the output of a program known to produce some output and then exit:
+ * {@snippet lang = "java" :
+ * List<String> capture(List<String> args) throws Exception {
+ *     ProcessBuilder pb = new ProcessBuilder(args);
+ *     Process process = pb.start();
+ *     try (BufferedReader in = process.inputReader()) {
+ *         List<String> captured = in.readAllLines();
+ *         int status = process.waitFor();
+ *         if (status != 0) {
+ *             throw new RuntimeException("Process %d: %s failed with %d"
+ *                         .formatted(process.pid(), args, status));
+ *         }
+ *         return captured;
+ *     }
+ * }
+ * }
+ * <p>Stream resources (file descriptor or handle) are always paired; one in the invoking process
+ * and the other end of that connection in the invoked process.
+ * Closing a stream at either end terminates communication but does not have any direct effect
+ * on the other Process. The closing of the stream typically results in the other process exiting.
+ *
+ * <p> {@linkplain #destroy Destroying a process} signals the operating system to terminate the process.
+ * It is up to the operating system to clean up and release the resources of that process.
+ * Typically, file descriptors and handles are closed. When they are closed, any connections to
+ * other processes are terminated and file descriptors and handles in the invoking process signal
+ * end-of-file or closed. Usually, that is seen as an end-of-file or an exception.
+ *
  * @since   1.0
  */
 public abstract class Process {
@@ -127,6 +166,9 @@ public Process() {}
      * then this method will return a
      * <a href="ProcessBuilder.html#redirect-input">null output stream</a>.
      *
+     * <p>The output stream should be {@linkplain OutputStream#close closed}
+     * when it is no longer needed.
+     *
      * @apiNote
      * When writing to both {@link #getOutputStream()} and either {@link #outputWriter()}
      * or {@link #outputWriter(Charset)}, {@link BufferedWriter#flush BufferedWriter.flush}
@@ -159,9 +201,15 @@ public Process() {}
      * then the input stream returned by this method will receive the
      * merged standard output and the standard error of the process.
      *
+     * <p>The input stream should be {@linkplain InputStream#close closed}
+     * when it is no longer needed.
+     *
      * @apiNote
-     * Use {@link #getInputStream()} and {@link #inputReader()} with extreme care.
-     * The {@code BufferedReader} may have buffered input from the input stream.
+     * Use either this method or an {@linkplain #inputReader() input reader}
+     * but not both on the same {@code Process}.
+     * The input reader consumes and buffers bytes from the input stream.
+     * Bytes read from the input stream would not be seen by the reader and
+     * buffer contents are unpredictable.
      *
      * @implNote
      * Implementation note: It is a good idea for the returned
@@ -185,9 +233,15 @@ public Process() {}
      * then this method will return a
      * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
      *
+     * <p>The error stream should be {@linkplain InputStream#close closed}
+     * when it is no longer needed.
+     *
      * @apiNote
-     * Use {@link #getErrorStream()} and {@link #errorReader()} with extreme care.
-     * The {@code BufferedReader} may have buffered input from the error stream.
+     * Use either this method or an {@linkplain #errorReader() error reader}
+     * but not both on the same {@code Process}.
+     * The error reader consumes and buffers bytes from the error stream.
+     * Bytes read from the error stream would not be seen by the reader and the
+     * buffer contents are unpredictable.
      *
      * @implNote
      * Implementation note: It is a good idea for the returned
@@ -208,6 +262,16 @@ public Process() {}
      * If the {@code native.encoding} is not a valid charset name or not supported
      * the {@link Charset#defaultCharset()} is used.
      *
+     * <p>The reader should be {@linkplain BufferedReader#close closed}
+     * when it is no longer needed.
+     *
+     * @apiNote
+     * Use either this method or the {@linkplain #getInputStream input stream}
+     * but not both on the same {@code Process}.
+     * The input reader consumes and buffers bytes from the input stream.
+     * Bytes read from the input stream would not be seen by the reader and the
+     * buffer contents are unpredictable.
+     *
      * @return a {@link BufferedReader BufferedReader} using the
      *          {@code native.encoding} if supported, otherwise, the
      *          {@link Charset#defaultCharset()}
@@ -238,16 +302,21 @@ public final BufferedReader inputReader() {
      * then the {@code InputStreamReader} will be reading from a
      * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
      *
+     * <p>The reader should be {@linkplain BufferedReader#close closed}
+     * when it is no longer needed.
+     *
      * <p>Otherwise, if the standard error of the process has been redirected using
      * {@link ProcessBuilder#redirectErrorStream(boolean)
      * ProcessBuilder.redirectErrorStream} then the input reader returned by
      * this method will receive the merged standard output and the standard error
      * of the process.
      *
      * @apiNote
-     * Using both {@link #getInputStream} and {@link #inputReader(Charset)} has
-     * unpredictable behavior since the buffered reader reads ahead from the
-     * input stream.
+     * Use either this method or the {@linkplain #getInputStream input stream}
+     * but not both on the same {@code Process}.
+     * The input reader consumes and buffers bytes from the input stream.
+     * Bytes read from the input stream would not be seen by the reader and the
+     * buffer contents are unpredictable.
      *
      * <p>When the process has terminated, and the standard input has not been redirected,
      * reading of the bytes available from the underlying stream is on a best effort basis and
@@ -283,6 +352,16 @@ public final BufferedReader inputReader(Charset charset) {
      * If the {@code native.encoding} is not a valid charset name or not supported
      * the {@link Charset#defaultCharset()} is used.
      *
+     * <p>The error reader should be {@linkplain BufferedReader#close closed}
+     * when it is no longer needed.
+     *
+     * @apiNote
+     * Use either this method or the {@linkplain #getErrorStream error stream}
+     * but not both on the same {@code Process}.
+     * The error reader consumes and buffers bytes from the error stream.
+     * Bytes read from the error stream would not be seen by the reader and the
+     * buffer contents are unpredictable.
+     *
      * @return a {@link BufferedReader BufferedReader} using the
      *          {@code native.encoding} if supported, otherwise, the
      *          {@link Charset#defaultCharset()}
@@ -314,10 +393,15 @@ public final BufferedReader errorReader() {
      * then the {@code InputStreamReader} will be reading from a
      * <a href="ProcessBuilder.html#redirect-output">null input stream</a>.
      *
+     * <p>The error reader should be {@linkplain BufferedReader#close closed}
+     * when it is no longer needed.
+     *
      * @apiNote
-     * Using both {@link #getErrorStream} and {@link #errorReader(Charset)} has
-     * unpredictable behavior since the buffered reader reads ahead from the
-     * error stream.
+     * Use either this method or the {@linkplain #getErrorStream error stream}
+     * but not both on the same {@code Process}.
+     * The error reader consumes and buffers bytes from the error stream.
+     * Bytes read from the error stream would not be seen by the reader and the
+     * buffer contents are unpredictable.
      *
      * <p>When the process has terminated, and the standard error has not been redirected,
      * reading of the bytes available from the underlying stream is on a best effort basis and
@@ -346,14 +430,17 @@ public final BufferedReader errorReader(Charset charset) {
     /**
      * Returns a {@code BufferedWriter} connected to the normal input of the process
      * using the native encoding.
-     * Writes text to a character-output stream, buffering characters so as to provide
+     * Writes text to a character-output stream, buffering characters to provide
      * for the efficient writing of single characters, arrays, and strings.
      *
      * <p>This method delegates to {@link #outputWriter(Charset)} using the
      * {@link Charset} named by the {@code native.encoding} system property.
      * If the {@code native.encoding} is not a valid charset name or not supported
      * the {@link Charset#defaultCharset()} is used.
      *
+     * <p>The output writer should be {@linkplain BufferedWriter#close closed}
+     * when it is no longer needed.
+     *
      * @return a {@code BufferedWriter} to the standard input of the process using the charset
      *          for the {@code native.encoding} system property
      * @since 17
@@ -365,7 +452,7 @@ public final BufferedWriter outputWriter() {
     /**
      * Returns a {@code BufferedWriter} connected to the normal input of the process
      * using a Charset.
-     * Writes text to a character-output stream, buffering characters so as to provide
+     * Writes text to a character-output stream, buffering characters to provide
      * for the efficient writing of single characters, arrays, and strings.
      *
      * <p>Characters written by the writer are encoded to bytes using {@link OutputStreamWriter}
@@ -383,6 +470,9 @@ public final BufferedWriter outputWriter() {
      * ProcessBuilder.redirectInput} then the {@code OutputStreamWriter} writes to a
      * <a href="ProcessBuilder.html#redirect-input">null output stream</a>.
      *
+     * <p>The output writer should be {@linkplain BufferedWriter#close closed}
+     * when it is no longer needed.
+     *
      * @apiNote
      * A {@linkplain BufferedWriter} writes characters, arrays of characters, and strings.
      * Wrapping the {@link BufferedWriter} with a {@link PrintWriter} provides
@@ -674,11 +764,12 @@ public long pid() {
      * free the current thread and block only if and when the value is needed.
      * <br>
      * For example, launching a process to compare two files and get a boolean if they are identical:
-     * <pre> {@code   Process p = new ProcessBuilder("cmp", "f1", "f2").start();
-     *    Future<Boolean> identical = p.onExit().thenApply(p1 -> p1.exitValue() == 0);
-     *    ...
-     *    if (identical.get()) { ... }
-     * }</pre>
+     * {@snippet lang = "java" :
+     *     Process p = new ProcessBuilder("cmp", "f1", "f2").start();
+     *     Future<Boolean> identical = p.onExit().thenApply(p1 -> p1.exitValue() == 0);
+     *     ...
+     *     if (identical.get()) { ... }
+     * }
      *
      * @implSpec
      * This implementation executes {@link #waitFor()} in a separate thread
@@ -695,11 +786,11 @@ public long pid() {
      * External implementations should override this method and provide
      * a more efficient implementation. For example, to delegate to the underlying
      * process, it can do the following:
-     * <pre>{@code
+     * {@snippet lang = "java" :
      *    public CompletableFuture<Process> onExit() {
      *       return delegate.onExit().thenApply(p -> this);
      *    }
-     * }</pre>
+     * }
      * @apiNote
      * The process may be observed to have terminated with {@link #isAlive}
      * before the ComputableFuture is completed and dependent actions are invoked.