Question

We have 1000 threads that hit a web service and time how long the call takes. We wish for each thread to return their own timing result to the main application, so that various statistics can be recorded.
Please note that various tools were considered for this, but for various reasons we need to write our own.
What would be the best way for each thread to return the timing – we have considered two options so far :-
1. once a thread has its timing result it calls a singleton that provides a synchronised method to write to the file. This ensures that all each thread will write to the file in turn (although in an undetermined order – which is fine), and since the call is done after the timing results have been taken by the thread, then being blocked waiting to write is not really an issue. When all threads have completed, the main application can then read the file to generate the statistics.
2. Using the Executor, Callable and Future interfaces
Which would be the best way, or are there any other better ways ?
Thanks very much in advance
Paul

Answer 1

Use the latter method.

Your workers implement Callable. You then submit them to a threadpool, and get a Future instance for each.

Then just call get() on the Futures to get the results of the calculations.

import java.util.*;
import java.util.concurrent.*;

public class WebServiceTester {

  public static class Tester
        implements Callable {
    public Integer call() {
      Integer start = now();
      //Do your test here
      Integer end = now();
      return end - start;
    }
  }

  public static void main(String args[]) throws Exception {
    ExecutorService pool = Executors.newFixedThreadPool(1000);
    Set<Future<Integer>> set = new HashSet<Future<Integer>>();
    for (int i =0 ; i < 1000 i++) {
      set.add(pool.submit(new Tester()));
    }
    Set<Integer> results = new Set<Integer>();
    for (Future<Integer> future : set) {
      results.put(future.get());
    }

    //Manipulate results however you wish....
  }
}