CPUs, thread pools, and wasted time.

I'm trying to build an application that will use multiple cores
efficiently, but I'm running into to some difficulties. I've written a
simple small example to demonstrate the problem and attached it below.
When I run this program on my dual core computer I expect that both cores
should be actively running wasteTime() and my CPU utilization should be
nearly 100% on both, but this isn't the result I'm getting. A single CPU
is maxed out and the other one is sitting idle. This isn't what I want
for obvious reasons.

Can any explain to me why this is happening and what to do about it?

I know that one can fiddle with the amount of work done by each thread and
get it to behave correctly, but I don't know why it isn't behaving
correctly without this tweaking of parameters.

Thanks.

---
/*
 * Main.java
 *
 * Created on Sep 27, 2007, 4:57:59 AM
 *
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package threadtester;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 *
 * @author kt
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        while (true) {
            int threads = 2;

            ExecutorService executorService =
                    Executors.newFixedThreadPool(threads);

            Future[] futures = new Future[10000];
            for (int index = 0; index < 100; index++) {
                final int indexFinal = index;
                futures[index] = executorService.submit(new Callable() {
                    public Object call() throws Exception {
                        return new Double(wasteTime());
                    }
                });
            }

            executorService.shutdown();
            boolean tryAgain = false;
            do {
                try {
                    tryAgain = false;
                    executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
                } catch (InterruptedException ex) {
                    tryAgain = true;
                }
            } while (tryAgain);
        }
    }
    
    
    public static double wasteTime() {
        double sum = 0.0;
        for (int index = 0; index < 100; index++) {
            sum += Math.cos(index / 1000.0);
        }
        return sum;
    }

}