Problem with my application never exiting the main

[Julien Martin]

Hello,
I have an application that performs computations through a monte carlo simulation. I use a completion service but my main never exits.
Can anyone please help?
Thanks in advance,
Julien.

package mc;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class Lanceur {

    /**
     * @param args the command line arguments
     */
    public final static int NUM_SIMULATION = 100000;

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        Executor es = Executors.newFixedThreadPool(2);
        CompletionService cs = new ExecutorCompletionService(es);
        double total = 0.0;
        for (int i = 0; i < NUM_SIMULATION; ++i) {
            cs.submit((new Worker(50, 52, 0.2, 0.05, 0.5)));
        }

        for (int i = 0; i < NUM_SIMULATION; ++i) {
            Future<Double> future = cs.take();
            total = total + future.get();
        }
        System.out.println(Math.exp(-0.05 * 0.5) * total / NUM_SIMULATION);

    }
}

class Worker implements Callable<Double> {

    private final double strike;
    private final double initialStockPrice;
    private final double volatility;
    private final double riskFreeRate;
    private final double maturity;
    private double endStockPrice;
    private double payoff;

    Worker(double strike, double initialStockPrice, double volatility, double riskFreeRate, double maturity) {
        this.strike = strike;
        this.initialStockPrice = initialStockPrice;
        this.volatility = volatility;
        this.riskFreeRate = riskFreeRate;
        this.maturity = maturity;

    }

    private void computePayoff() {
        Random rand = new Random();
        endStockPrice = initialStockPrice * Math.exp((riskFreeRate - 0.5 * Math.pow(volatility, 2)) * maturity + volatility * Math.sqrt(maturity) * rand.nextGaussian());
        payoff = Math.max(0, endStockPrice - strike);
    }

    public Double call() throws Exception {
        computePayoff();
        return payoff;
    }
}

[Chris Hurst]

What about calling shutdown on the workers .. seems to work for me ...

package mc;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class Lanceur {

    /**
     * @param args the command line arguments
     */
    public final static int NUM_SIMULATION = 100000;

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService es = Executors.newFixedThreadPool(2);
        CompletionService cs = new ExecutorCompletionService(es);
        double total = 0.0;
        for (int i = 0; i < NUM_SIMULATION; ++i) {
            cs.submit((new Worker(50, 52, 0.2, 0.05, 0.5)));
        }

        for (int i = 0; i < NUM_SIMULATION; ++i) {
            Future<Double> future = cs.take();
            total = total + future.get();
        }
        System.out.println(Math.exp(-0.05 * 0.5) * total / NUM_SIMULATION);
        es.shutdown();
    }
}

class Worker implements Callable<Double> {

    private final double strike;
    private final double initialStockPrice;
    private final double volatility;
    private final double riskFreeRate;
    private final double maturity;
    private double endStockPrice;
    private double payoff;

    Worker(double strike, double initialStockPrice, double volatility, double riskFreeRate, double maturity) {
        this.strike = strike;
        this.initialStockPrice = initialStockPrice;
        this.volatility = volatility;
        this.riskFreeRate = riskFreeRate;
        this.maturity = maturity;

    }

    private void computePayoff() {
        Random rand = new Random();
        endStockPrice = initialStockPrice * Math.exp((riskFreeRate - 0.5 * Math.pow(volatility, 2)) * maturity + volatility * Math.sqrt(maturity) * rand.nextGaussian());
        payoff = Math.max(0, endStockPrice - strike);
    }

    public Double call() throws Exception {
        computePayoff();
        return payoff;
    }
}

[Julien Martin]

Thanks Chris!