The issue is not whether the process is in the foreground or background. When you start a process using Java, you have to use Java to control that process' lifecyle. The Java API provides you access to various attributes of the process. What you're interested in here is the output of the process. That is represented by the process' InputStream. It seems counterintuitive, but it makes sense because from the perspective of your Java program, the process' output is the program's input. Conversely, if you need to send data to the process, you write to the process' OutputStream.

To sum up, access the process' InputStream and print that out to the command-line:

Process process = new ProcessBuilder("C:\\Path\\To\\My\\Application.exe").start();

BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));

StringBuilder output = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
    output.append(line);
}

System.out.println(line);

This code, of course, assumes that your process is not waiting for any input, i.e., it is not interactive.

You cannot do this using pure java. There is a difference between running process and accessing the window created by other process. To achieve this goal you have to use plarform specific APIs, for example JNI/JNA either directly or indirectly.

Take a look on this project: https://github.com/twall/jna I hope it can be helpful.

The problem is, once the Java program finishes executing, all sub-processes are closed, also the Ruby Script.

On *nix systems (POSIX really, including Debian Linux) the process is sent a HUP signal (SIGHUP or hangup) when its' parent process ends. You can use the nohup(1) command when you start a subprocess to ignore the hangup from the child process.

Alternatively, you could potentially make use of the Ruby Signal Module and use Signal.trap(HUP) to handle it some other way.

Just do the entire thing in a new thread.

Wrap the entire above code in a Runnable and start a Thread for it. Your main code can continue doing something else. In the runnable once you get the result from the child process use some notify(or observer pattern) to notify interested parties.

You can do this with kill. To pause a process do kill -STOP <pid> and to continue it kill -CONT <pid>.

Huh. Using ProcessBuilder should work for your configuration. For example, the following pattern works for me:

ProcessBuilder pb = new ProcessBuilder("/tmp/x");
Process process = pb.start();
final InputStream is = process.getInputStream();
// the background thread watches the output from the process
new Thread(new Runnable() {
    public void run() {
        try {
            BufferedReader reader =
                new BufferedReader(new InputStreamReader(is));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            is.close();
        }
    }
}).start();
// the outer thread waits for the process to finish
process.waitFor();

The program that I'm running is just a script with a whole bunch of sleep 1 and echo lines:

#!/bin/sh
sleep 1
echo "Hello"
sleep 1
echo "Hello"
...

The thread reading from the process spits out a Hello every second or so.