Tukukkk

I am trying to use fixed thread pool in Java 8 which works perfect as long as it stays within the same function. Once I try sharing the executor as a parameter, it never runs in parallel.

This works great:

```

public static void test2() {



ExecutorService executor =  Executors.newFixedThreadPool(2);

try {

    CompletionService<Integer> myCompletionService = 

               new ExecutorCompletionService<Integer>(executor);





    myCompletionService.submit(()-> {

        try {

            TimeUnit.SECONDS.sleep(5);

            return 123;

        }

        catch (InterruptedException e) {

            throw new IllegalStateException("task interrupted", e);

        }

    });





    CompletionService<Integer> myCompletionService2 = 

               new ExecutorCompletionService<Integer>(executor);

    myCompletionService2.submit(()-> {

        try {

            TimeUnit.SECONDS.sleep(5);

            return 654;

        }

        catch (InterruptedException e) {

            throw new IllegalStateException("task interrupted", e);

        }

    });



    Future<Integer> myFuture = myCompletionService.take();

    Integer x = myFuture.get();

    System.out.println("Result = " + x);



    Future<Integer> myFuture2 = myCompletionService2.take();

    Integer y = myFuture2.get();

    System.out.println("Result = " + y);



    executor.shutdown();

} catch (InterruptedException | ExecutionException e1) {

    // TODO Auto-generated catch block

    e1.printStackTrace();

}

}

```

But once I move these into three functions like:

```

static Integer t1(ExecutorService executor) throws InterruptedException, ExecutionException {

    CompletionService<Integer> myCompletionService = 

               new ExecutorCompletionService<Integer>(executor);





    myCompletionService.submit(()-> {

        try {

            TimeUnit.SECONDS.sleep(5);

            return 123;

        }

        catch (InterruptedException e) {

            throw new IllegalStateException("task interrupted", e);

        }

    });

    Future<Integer> myFuture = myCompletionService.take();

    return myFuture.get();

}



static Integer t2(ExecutorService executor) throws InterruptedException, ExecutionException {

    CompletionService<Integer> myCompletionService2 = 

               new ExecutorCompletionService<Integer>(executor);





    myCompletionService2.submit(()-> {

        try {

            TimeUnit.SECONDS.sleep(5);

            return 456;

        }

        catch (InterruptedException e) {

            throw new IllegalStateException("task interrupted", e);

        }

    });

    Future<Integer> myFuture2 = myCompletionService2.take();

    return myFuture2.get();

}



static void test3() {

    ExecutorService executor =  Executors.newFixedThreadPool(5);

    try {

        Integer x = t1(executor);

        Integer y = t2(executor);

    } catch (InterruptedException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    } catch (ExecutionException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

    }

    executor.shutdown();

}

```
Now test3 will take 10 seconds, where I expected it to be the same as the top one which should take 5 seconds if things are running in parallel.,

In t1 after submitting you are calling get() and get blocked, so you exit from t1 only when first task is finished (after 5 secs).

In first example you submit both tasks so they starting executing in separate threads and then only call get() to block and wait for result.