Running java runtime.exec() for multiple process

Question

In my program I do have a list of n items.

I will be iterating the list and initiate a process like this:

Runtime.getRuntime.exec("cmd /C start abc.bat"+listitem() )

I need to maintain a count of 4 processes. Once any one of the process is completed, I need to start the next process , so the process count should be 4.

I am able to initiate 4 process simultaneously, but not sure on how to keep the count of 4. Basically I need some notification once a process is terminated, so I can start the next, any threading is possible.

Any help on how to implement this, can somebody share a snippet on this above requirement?

Answer 1

You should have four threads that each take an assignment from a pool, then carry it out, then when it is done, carry out the next assignment. This would be how:

class Whatever extends Thread {
    public void run() {
        while (!interrupted()) {
            String str = listitem();
            if (str == null) // there are no more commands to run
                break;
            Runtime.getRuntime.exec(("cmd /C start abc.bat"+str).split("\\s")).waitFor();
}

Then start four of these threads.

Answer 2

Use an ThreadPoolExecutor of size 4 and a Runnable implementation which starts the Process and then invokes Process.waitFor(). Since the thread pool will be restricted to 4 threads and all 4 threads will start a process and then wait for it, you'll be certain there won't be more than 4 child processes running.

Some sample code to help you along your way:

ExecutorService executor = Executors.newFixedThreadPool(4);

executor.execute(new Runnable() {
    public void run() {
        //use ProcessBuilder here to make the process
        Process p = processBuilder.start();
        p.waitFor();
    }
});

Answer 3

 public class ProcessRunner {

    public static void main(String[] args) throws IOException, InterruptedException {
        //Creating n threads as required
        ExecutorService exec = Executors.newFixedThreadPool(4);
        for(int i = 0; i < 4; i++){
            exec.execute(new ProcessRunnable());
        }

        Thread.sleep(10000);

        //whenever you want them to stop
        exec.shutdownNow();

    }   

}

class ProcessRunnable implements Runnable{
       @Override
       public void run(){
        do{
           Process p;
        try {
            p = Runtime.getRuntime().exec("cd ..");
            p.waitFor(); 
        } catch (IOException e) {
                    //Take appropriate steps
            e.printStackTrace();
        } catch (InterruptedException e) {
                    //Take appropriate steps
            e.printStackTrace();
        }

        }while(!Thread.interrupted());
       }
}

Process#waitFor()

Causes the current thread to wait, if necessary, until the process represented by this Process object has terminated. This method returns immediately if the subprocess has already terminated. If the subprocess has not yet terminated, the calling thread will be blocked until the subprocess exits.

Answer 4

You can use fixed thread pool with size 4 which guarantees no more than 4 active threads at any given moment

    final ExecutorService ex = Executors.newFixedThreadPool(4);
    for(int i = 0; i < 100; i++) {
        ex.execute(new Runnable() {
            @Override
            public void run() {
              ... run the process here and wait for it to end
            }
        });
    }