Thread (maintain current thread)

[Caden Whitaker]

This is a pretty basic problem.

I'm working on a piece of middleware between two large applications that cannot be altered. My little function is the squishy bit in the middle

Application #1: A huge computational powerhouse that has an exposed jar with one function that I use (simulated here by the function runAlgorithm)

Application #2: A desktop UI that calls my middleware and expects a result in the same thread.

Here's some sample code

  public static Long runAlgorithm() throws Exception {
        int time = (int) ( 200 + Math.random() * 800);
        Thread.sleep(time);
        Long random = new Double(2 + Math.random() *8).longValue();
        return random;
    }
   
    public static int performFunction() {
        ArrayList<Long> values = new ArrayList<Long>();
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
        values.add(runAlgorithm());
       
        int total = 0;
        for(Long l : values) {
            total += l;
        }
        return (total / values.size());
    }

    public static void main(String[] args) throws Exception {
        System.out.print.line(performFunction());
    }

The problem:
So looking at the example code, main() is basically the UI calling my function. I cannot edit main(), I cannot do anything to main. It calls my function and expects a result

Also runAlgorithm() is the massive server behind the scenes. I cannot edit runAlgorithm, I cannot do anything other than expect a result.

Instead of chaining all my runAlgorithm()'s in a row, it is perfectly fine for me to thread them out in my performFunction() call. My question is what would be (given the sparse details above) the best way to proceed? Should I thread out all of my runAlgorithms() and sleep inside performFunction() until they all respond? Is there a better way?

Any help would be appreciated.

Thanks!

[Paul Clapham]

If you want to start ten separate threads to do the ten separate calls to runAlgorithm(), sure, go ahead. But you don't need to do any sleeping while you're waiting for the threads to complete. Just start the threads, then call each of their join() methods.

[Ireneusz Kordal]

Try this code - it uses ThreadPool and Future/Callable interfaces,
with this code you dont need to deal with synchronization of threads - it is done automatically for you,
and you can easy control the number of threads in ThreadPool (sometimes too many simultaneous threads is not a good idea).

class Main {

    public static Long runAlgorithm() throws InterruptedException {
        int time = (int) (200 + Math.random() * 800);
       
            Thread.sleep(time);
       
        Long random = new Double(2 + Math.random() * 8).longValue();
        return random;
    }

    public static int performFunction()  {
        
        ArrayList<Long> values = new ArrayList<Long>();
        ExecutorService ex = Executors.newFixedThreadPool(4); // number of threads

        final int RESULTS = 10;

        Future<Long>[] results = new Future[RESULTS];
        for (int i = 0; i < RESULTS ; i++) {
            results[i] = ex.submit(
                    new Callable<Long>() {
                        public Long call() throws InterruptedException {
                            return runAlgorithm();
                        }
                    });
        }
        ex.shutdown();
        
        for( Future<Long> f : results){
            try {
                values.add(f.get());
            } catch (InterruptedException ex1) {
                //...
            } catch (ExecutionException ex1) {
               //... deal with exceptions thrown in runAlgorithm
            }
        }

        int total = 0;
        for (Long l : values) {
            total += l;
        }
        return (total / values.size());
    }

    public static void main(String[] args) throws Exception {
        System.out.println(performFunction());
    }
}

[Paul Clapham]

Even better than my quick-and-dirty suggestion. One day I will have to learn about the Java 5 concurrency classes properly.