La clase Process abstracta es un proceso, es decir, un programa en ejecución. Los métodos proporcionados por el proceso se utilizan para realizar entradas, salidas, esperar a que se complete el proceso, verificar el estado de salida del proceso y destruir el proceso.
- Extiende la clase Object .
- Se usa principalmente como una superclase para el tipo de objeto creado por exec() en la clase Runtime.
- Los métodos ProcessBuilder.start() y Runtime.getRuntime.exec() crean un proceso nativo y devuelven una instancia de una subclase de Process que se puede usar para controlar el proceso y obtener información sobre él.
- ProcessBuilder.start() es la forma preferida de crear un proceso.
ProcessBuilder.start() vs Runtime.getRuntime.exec(): ProcessBuilder nos permite redirigir el error estándar del proceso secundario a su salida estándar. Ahora no necesitamos dos subprocesos separados, uno leyendo desde stdout y otro leyendo desde stderr . Constructor
- Process(): Este es el único constructor.
Métodos:
- void destroyForcably(): Mata el subproceso.
Syntax: public abstract void destroyForcibly(). Returns: NA. Exception: NA.
Java
// Java code illustrating destroyForcibly() // method for windows operating system // Class public class ProcessDemo { // Main driver method public static void main(String[] args) { try { // create a new process System.out.println(" Creating Process & quot;); ProcessBuilder builder = new ProcessBuilder( " notepad.exe & quot;); Process pro = builder.start(); // wait 10 seconds System.out.println(" Waiting & quot;); Thread.sleep(10000); // kill the process pro.destroyForcibly(); System.out.println(" Process destroyed & quot;); } catch (Exception ex) { ex.printStackTrace(); } } }
Producción:
Creating Process Waiting Process destroyed
Java
// Java code illustrating destroyForcibly() // method for Mac Operating System import java.io.*; import java.lang.*; class ProcessDemo { public static void main(String arg[]) throws IOException, Exception { System.out.println(" Creating process & quot;); // creating process ProcessBuilder p = new ProcessBuilder(new String[] { " open& quot; , " / Applications / Facetime.app& quot; }); Process pro = p.start(); // waiting for 10 second Thread.sleep(10000); System.out.println(" destroying process & quot;); // destroying process pro.destroyForcibly(); } }
Producción:
Creating process destroying process
int exitValue(): este método devuelve el valor de salida del subproceso.
Syntax: public abstract int exitValue(). Returns: This method returns the exit value of the subprocess represented by this Process object. By convention, the value 0 indicates normal termination. Exception: IllegalThreadStateException , if the subprocess represented by this Process object has not yet terminated.
Java
// Java code illustrating exitValue() method public class ProcessDemo { public static void main(String[] args) { // Try block to check for exceptions try { // create a new process System.out.println(" Creating Process & quot;); ProcessBuilder builder = new ProcessBuilder( " notepad.exe & quot;); Process pro = builder.start(); // kill the process pro.destroy(); // checking the exit value of subprocess System.out.println(" exit value : " + pro.exitValue()); } // Catch block to handle the exceptions catch (Exception ex) { ex.printStackTrace(); } } }
Producción:
Creating Process 1
abstract InputStream getErrorStream(): este método obtiene el flujo de entrada del subproceso.
Syntax: public abstract InputStream getInputStream(). Returns: input stream that reads input from the process out output stream. Exception: NA.
Java
// Java code illustrating // getInputStream() method import java.io.*; import java.lang.*; class ProcessDemo { public static void main(String arg[]) throws IOException, Exception { // creating the process Runtime r = Runtime.getRuntime(); // shell script for loop from 1 to 3 String[] nargs = { " sh& quot; , " -c& quot; , "for i in 1 2 3; do echo $i; done& quot; }; Process p = r.exec(nargs); BufferedReader is = new BufferedReader( new InputStreamReader(p.getInputStream())); String line; // reading the output while ((line = is.readLine()) != null) System.out.println(line); } }
Producción:
1 2 3
abstract OutputStream getOutputStream(): este método obtiene el flujo de salida del subproceso. La salida al flujo se canaliza al flujo de entrada estándar del proceso representado por este objeto Process.
Syntax: public abstract OutputStream getOutputStream() Returns: the output stream connected to the normal input of the subprocess. Exception: NA.
Java
// Java code illustrating // getOutputStream() method import java.io.BufferedOutputStream; import java.io.OutputStream; public class ProcessDemo { public static void main(String[] args) { try { // create a new process System.out.println("Creating Process"); Process p = Runtime.getRuntime().exec("notepad.exe"); // get the output stream OutputStream out = p.getOutputStream(); // close the output stream System.out.println("Closing the output stream"); out.close(); } catch (Exception ex) { ex.printStackTrace(); } } }
Producción:
Creating Process... Closing the output stream...
abstract InputStream getErrorStream(): devuelve un flujo de entrada que lee la entrada del flujo de salida del error del proceso .
Syntax: public abstract InputStream getErrorStream(). Returns: the input stream connected to the error stream of the subprocess. Exception: NA.
Java
// Java code illustrating // getErrorStream() method import java.io.InputStream; public class ProcessDemo { public static void main(String[] args) { try { // create a new process System.out.println("Creating Process"); Process p = Runtime.getRuntime().exec("notepad.exe"); // get the error stream of the process and print it InputStream error = p.getErrorStream(); for (int i = 0; i < error.available(); i++) { System.out.println("" + error.read()); } // wait for 10 seconds and then destroy the process Thread.sleep(10000); p.destroy(); } catch (Exception ex) { ex.printStackTrace(); } } }
Producción:
Creating Process
int waitFor(): Devuelve el código de salida devuelto por el proceso. Este método no regresa hasta que finaliza el proceso en el que se llama.
Syntax: public int waitFor(). Returns: the exit value of the process. By convention, 0 indicates normal termination. Exception: throws InterruptedException.
Java
// Java code illustrating // waitFor() method public class ProcessDemo { public static void main(String[] args) { try { // create a new process System.out.println("Creating Process"); Process p = Runtime.getRuntime().exec("notepad.exe"); // cause this process to stop // until process p is terminated p.waitFor(); // when you manually close notepad.exe // program will continue here System.out.println("Waiting over"); } catch (Exception ex) { ex.printStackTrace(); } } }
- Producción:
Creating Process... Waiting over.
Este artículo es una contribución de Abhishek Verma . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA