Monitoring a Process using Runtime.exce()

Question

Hi,
In my Program, I'm using the
new BufferedReader(new InputStreamReader(Runtime.getRuntime()                         .exec("ps -ef | grep xmlfeed").getInputStream()));
The above statement is not returning any inputstream to the BuffredReader.
When I gave the command as "PWD", it's returning the lines as expected.
But it's not working even for "PS" command also.I'm running this in AIX machine.
Any Ideas,Please help....
Edited by: haijdp on Dec 21, 2007 1:11 AM

Answer 1

Hello! And sorry I didn't reply earlier. I hope the Original Poster will find revisit this thread and it helps him.
From your post I assumed that you were not a student trying to create some homework. That's why I felt free to simply code a solution and submit the code here. But first some remarks:
I don't think that your code can work. Runtime.exec expects an array of type String, where the first element is the command and subsequent elements are a command line option each. I don't think you can use the pipe and call several commands using Runtime.exec, but that's just a kind of guess. YMMV.
Running external Processes in Java is a bit complicated. Basically,
* It's good to run the process in it's own thread. That way the main program can continue without getting stuck.
* To extract stdout and stderr of your target process you must run two threads, one for stderr and one for stdout. Both threads extract the characters of their respective streams in a loop that runs inside the thread. Again, that way we avoid deadlocks, program getting stuck etc.
This explanation is terrible, I know - I think a slice of source code speaks louder than words. I have attached five java files which together make a little process runner which extracts stdout and stderr in a safe manner. To run:
* Cut'n paste them into five text files, one per class.
* Save the each text file as {contained-class-name}.java
* Compile the stuff
* Run RunnerDemo (When I ran it, I got a directory listing printed on the console)
Explanation sounds a bit sloppy, but I did it under the assumption that you are a seasoned java pro, so it should not pose any problems. Since you seem to be a different OS than I (AIX, I run Linux), the command may or may not work. Try other commands. For example, in the RunnerDemo class you could set the cmd field to this:
        String [] cmd =
            "ps",
            "-A",
            "-H"
        };This would give you a process listing (works on Linux).
By the way, commands are passed as array. See Java documentation for java.lang.Runtime.exec (String []) for explanation of this array.
One problem I see in your command is that the output of ps is piped to some other program. Sorry, I don't know whether my code could achieve this. All it can do is to rum one single command with command line options. But you should be able to adjust the given example, so it supports piping to another program.
If you have any further questions, please don't hesitate to ask!
Class: RunnerDemo
*                           RunnerDemo.java
*                     Demo for the process runner
package rtimeexec;
public class RunnerDemo
    public static void main (String [] args)
        String [] cmd =
            "ls",
            "-a",
            "-l"
        ProcessRunner   runner;
        String          stdOutStr;
        String          stdErrStr;
        runner = new ProcessRunner (cmd);
        runner.start ();
        runner.BlockUntilFinished ();
        stdOutStr = runner.GetStdOutText ();
        stdErrStr = runner.GetStdErrText ();
        System.out.println ("Process result, ls -a -l");
        System.out.println ("-----------------------------------------------------------------------");
        System.out.println ("Stdout:");
        System.out.println ("-----------------------------------------------------------------------");
        System.out.println (stdOutStr);
        System.out.println ();
        System.out.println ("-----------------------------------------------------------------------");
        System.out.println ("Stderr:");
        System.out.println ("-----------------------------------------------------------------------");
        System.out.println (stdErrStr);
Class: ProcessRunner
package rtimeexec;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
* Runs a system process and extracts stdout and stderr of that process.
* Process will run in its own thread, so that the caller can simply continue
* with less of a chance to get locked down. Caller can invoke the {@link BlockUntilFinished}
* method after starting this thread. This method blocks until the thread is finished,
* i.e. the process has finished.
* Unfortunately, we haven't implemented any facility to stream characters to
* stdin of the process called. If that facility would exist we could refactor
* the classes and realize some sort of piping facility, as it's possible in
* Linux, for example.
* Example on how to run a process:
* <pre>
* String []         cmd  = {"ps", "-AH"};
* String            sOut;
* String            sErr;
* ProcessRunner     runner;
* runner = new ProcessRunner (cmd);
* runner.start ();
* runner.BlockUntilFinished ();
* sOut = runner.GetStdOutText ();
* sErr = runner.GetStdErrText ();
* System.out.println ("Stdout:");
* System.out.println (sOut);
* System.out.println ("------------------------------------------------------");
* System.out.println ("Stderr:");
* System.out.println (sErr);
* </pre>
public class ProcessRunner extends Thread
    private String []                   command;
    private int                         execResult;
    private String                      stdOutText;
    private String                      stdErrText;
    private boolean                     isFinished;
    public ProcessRunner (String [] cmd)
        command     = cmd;
        execResult  = 0;
        stdOutText  = null;
        stdErrText  = null;
        isFinished  = false;
    public int GetResult ()
        return execResult;
    public String GetStdOutText ()
        return stdOutText;
    public String GetStdErrText ()
        return stdErrText;
    public boolean IsFinished ()
        return isFinished;
    public void BlockUntilFinished ()
        while (! isFinished)
            try {Thread.sleep (250);} catch (InterruptedException e) {}
    public void run ()
        Process         proc;
        Runtime         rt;
        InputStream     stdOut;
        InputStream     stdErr;
        CharStream      stdOutEx;
        CharStream      stdErrEx;
        int             res;
        isFinished = false;
        try
            res         = 0;
            rt          = Runtime.getRuntime ;       ();
            proc        = rt.exec ;                  (command);
            stdOut      = proc.getInputStream ;      ();
            stdErr      = proc.getErrorStream ;      ();
            stdOutEx    = new CharStream            (stdOut);
            stdErrEx    = new CharStream            (stdErr);
            stdOutEx.start ();
            stdErrEx.start ();
            try {res = proc.waitFor ();} catch (InterruptedException e) {}
            // Process has finished; now wait until any buffers are empty.
            stdOutEx.BlockUntilFinished ();
            stdErrEx.BlockUntilFinished ();
            stdOutText = stdOutEx.GetResult ();
            stdErrText = stdErrEx.GetResult ();
            execResult = res;
        catch (IOException e)
            isFinished = true;
            throw new ExtractionException (e.getLocalizedMessage());
        isFinished = true;
Class: CharStream
package rtimeexec;
import java.io.IOException;
import java.io.InputStream;
* A Character extractor. Extracts characters from a stream and puts them
* into a String. To protect from memory overflow we put a limit in place.
* When storage demads exceed that limit, an exception is thrown.
public class CharStream extends Thread
    private static final int    maxChunkLen         = 8192;
    private static final int    maxStorageSize      = 512 * 1024;   // 512 KBytes
    private InputStream     sourceStream;
    private StringBuffer    extracted;
    private boolean         isFinished;
    public CharStream (InputStream istream)
        sourceStream    = istream;
        extracted       = new StringBuffer ();
        isFinished      = false;
    public String GetResult ()
        String ret;
        ret = extracted.toString ();
        return ret;
    public void BlockUntilFinished ()
        while (! isFinished)
            SleepThread (250);
    public void run ()
        byte []                 buffer;
        int                     nBytesRead;
        byte                    b;
        char                    c;
        int                     iChar;
        int                     nCharsTotal;
        boolean                 isEOF;
        isEOF       = false;
        nCharsTotal = 0;
        isFinished = false;
        while (! isEOF)
            try
                buffer      = new byte [maxChunkLen];
                nBytesRead  = sourceStream.read (buffer);
                if (nBytesRead >= 1)
                {   // much faster stream extraction method than when we use
                    // BufferedReader(new InputStreamReader(sourceStream)).
                    for (iChar = 0; iChar < nBytesRead; iChar++)
                        nCharsTotal++;
                        if (nCharsTotal > maxStorageSize)
                            throw new StoreFullException
                                "Storage limit exceeded (" + Integer.toString (maxChunkLen) + "Bytes)"
                        b = buffer [iChar];
                        c = (char) b;
                        extracted.append (c);
                else if (nBytesRead <= -1)
                    isEOF       = true;
            catch (IOException e)
                isFinished = true;
                throw new ExtractionException (e.getLocalizedMessage());
            SleepThread (250);
        isFinished  = true;
    private void SleepThread (int mSec)
        try
            Thread.sleep (mSec);
        catch (InterruptedException e)
Class: StoreFullException
package rtimeexec;
* Exception that gets thrown when a storage container is full.
public class StoreFullException extends RuntimeException
    private static final long serialVersionUID = - 4996246591135389009L;
    public StoreFullException (String message)
        super (message);
Class: ExtractionException
package rtimeexec;
* Thrown when there was some problem during stream extraction.
public class ExtractionException extends RuntimeException
    private static final long serialVersionUID = - 6124525536783450209L;
    public ExtractionException (String message)
        super (message);
}