Order of execution of Callable objects in an ExecutorService

Question

what determines the order of execution of Callable objects in an ExecutorService ?
here is my test code:
    ExecutorService exe = Executors.newCachedThreadPool();
    Set<Callable<String>> tasks = new HashSet<Callable<String>>();
    for (int i = 0; i < 10; i++) {
      Worker worker = new Worker(i);
      tasks.add(worker);
    List<Future<String>> results = exe.invokeAll(tasks);
    for(int i = 0; i < results.size(); i++) {
      Future f = (Future) results.get(i);
      String s = (String) f.get();
      System.out.println("__" + s);
public class Worker implements Callable<String> {
  private int seqNumb = -111;
  public Worker(int i) {
    this.seqNumb = i;
  public String call() {
    double d = Math.random();
    int i = (int) (d * 10000);
    Thread.sleep(i);
    return (Integer.toString(i) + "___" + seqNumb);
}i ran this code within NetBeans on one XP machine. and ran it from the command line on a different XP machine.
the sequence is always:
*6*
*9*
*4*
*3*
*8*
*1*
*0*
*5*
*2*
*7*
the sequence should be random because of the random wait???
the sequence looks random. why does "6" come before "9"? why is "7" last?
yet, the sequence is always the same.
i can't understand the order of execution of the Callable objects.
note:
what i'm trying to do is implement my own version of the ExecutorService interface.
so, its important to understand the above question?
Edited by: kogose on Feb 9, 2009 6:53 PM

Answer 1

jtahlborn wrote:
ejp wrote:
2. The order of execution is defined by the queue associated with the ExecutorService. Normally it is a FIFO, but one can imagine using a PriorityQueue, given some kind of priority implementation in the submitted tasks.just to be clear for others who may be reading this, the order of submission is controlled by the queue implementation (where submission is the movement of a Callable from a queue to a thread). once the Callables are passed to threads, their actual order of execution is undefined (where execution is the invocation of the "call" method).And not only that, but even if we knew that the order of execution were call1, call2, call3, that still doesn't tell us anything, since there's no synchronization here, and hence any thread can be swapped out at any time. Call1 could be entered, but then swapped out before it gets to print anything, etc.
Bottom line: When you're dealing with multiple threads, unless you use synchronization, wait, notify(All), or higher level java.util.concurrent constructs, you have no ability to control or predict what executes when.