Clase Java.lang.Process en Java

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:

1. void destroyForcably(): Mata el subproceso.

Syntax: public abstract void destroyForcibly().
Returns: NA.
Exception: NA.

// 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 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 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 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 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 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 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();
        }
    }
}

1. 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.