Ideas on running a batch of threads?

Question

Hi All,
I have a class which makes system calls. However, sometimes it is ok to wait for the method to finish, but then sometimes it would be much more efficient to make multiple calls at the same time and wait for them all to finish. So I wanted to augment my SystemCaller class such that it has the ability to do both, and the usage of this class would be very simple and not require much coding from a user point of view.
I'm just wondering if anyone had any other suggestions to this?
Here is a comparison:
This is the normal way, which may be ok in some cases for my app:
// No suprises, just init an object and make the call.
SystemCaller systemCaller1 = new SystemCaller();
SystemCaller systemCaller2 = new SystemCaller();
// Since each one runs in turn, it will take 2
// seconds to complete
systemCaller1.sleep(1000);
systemCaller2.sleep(1000);And this would be the more efficient way:
SystemCaller systemCaller1 = new SystemCaller();
SystemCaller systemCaller2 = new SystemCaller();
// Inform the class that when a method is called, do NOT execute the
// command.  Save the command and just return null.
systemCaller1.setRunnable(true);
systemCaller2.setRunnable(true);
// Because boolean is set, the command is not executed right here. Instead
// the command string will be saved and these methods return null.
systemCaller1.sleep(1000);
systemCaller2.sleep(1000);
// Now set up our batch job.
Thread thread1 = new Thread(systemCaller1);
Thread thread2 = new Thread(systemCaller2);
// Begin actual execution
thread1.start();
thread2.start();
// It doesn't make sense in our program to continue until all jobs are done.
// This coding method will only take 1 second instead of 2.
thread1.join();
thread2.join();In the second example, the time to execute would be cut in half because both commands are executed simultaneously. Here is what the execute method would look like:
public class SystemCaller implements Runnable {
public Result sleep(int msec) {
        this.systemCall = new SystemCall();
        this.executeCmd = "sleep " + msec;
        if(!runnable) {
            // Execute the command NOW and return the result.
            Result result = systemCall.execute(cmd);
            return result.getStdout();
        else {
            //The command string is saved for later execution. Do nothing.
            return null;
}Thanks for any comments. I just wanted to work out this idea and see if anyone would shoot it down with something better.

Answer 1

Yes, I do want the class to be two things at once.
The first suggestion with the code sample seems interesting. You mentioned that it wouldn't be friendly from an external/user point of view? It doesn't seem any more unfriendly that what I had.
I like the idea in the sense that I can setup my command to run, but the command is not executed until I call getResult(). So usage would be like this (I'm using an example. Assume it takes the system a long time to print out "Hello World" :-).
// Create objects - no suprise
SystemCaller systemCaller1 = new SystemCaller();
SystemCaller systemCaller2 = new SystemCaller();
// Although we call the function here, it is not executed until
// we call getResult();
systemCaller1.echoCmd("Hello world!");
systemCaller2.echoCmd("Hello world!");
// Here is where the actual call is made
Result result1 = systemCaller1.getResult();
Result result2 = systemCaller2.getResult();
// Same old...
SystemCaller systemCaller1 = new SystemCaller();
SystemCaller systemCaller2 = new SystemCaller();
// Prepare the commands to run
systemCaller1.echoCmd("Hello world!");
systemCaller2.echoCmd("Hello world!");
// Wrap them in a thread. Since SystemCaller implements
// the run() method, it will be called automatically when
// we start.
Thread thread1 = new Thread(systemCaller1);
Thread thread2 = new Thread(systemCaller2);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
// The results are waiting, so just get it.
Result result1 = systemCaller1.getResult();
Result result2 = systemCaller2.getResult();MMmmm, thanks for all the comments. If anyone cares to elaborate, feel free.