Try this approach:

public class Foobar extends Callable<Integer> {
  final int param;
  public Foobar(int param) {
     this.param = param;
  }

  public Integer call() {
     return foo(param);
  }

   public int foo(int i) {
     return i * 2;
   }
}
public class Main {
 public static void main(String..args) throws Exception {
   Executor tp = Executors.newFixedThreadPool(10);
   List<Future<Integer>> futureObjects = new
ArrayList<Future<Integer>>();
   for (int i =1; i <=10000; i++) {
     futureObjects.add(tp.execute(new Foobar(i)));
   }
   for (Future<Integer> result: futureObjects) {
     System.out.println(result.get());
   }
}

You'd need a synchronized method that can keep the sum, and then pass
that as a callback to the thread.

Also, you'd need to wait till all threads are done executing - which
is why I do not think threading is a good solution for this case.

For example:

class Calculator{

  private int total;

  public synchronized void add(int result){

   total+=result;

  }

  public void spawnThreads(){

     for(int i=0;i<10000;i++){
        //spawn the threads, passing in this Calculator as a
reference
        //have the thread's run() call add(result) once it has
calculated the value
        //join() on the thread <--- this is why threading will not
help here!
     }

  }

In other words, since the sum is dependent on complete execution of
all the theads taking part in the computation, evaluating the sum is
in a way a blocking call (and hence the join() is needed).

-cheers,
Manish