java - Why is CompletableFuture.supplyAsync succeeding a random number of times?

Question

I'm new to both lambdas and asynchronous code in Java 8. I keep getting some weird results...

I have the following code:

import java.util.concurrent.CompletableFuture;

public class Program {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            String test = "Test_" + i;
            final int a = i;

            CompletableFuture<Boolean> cf = CompletableFuture.supplyAsync(() -> doPost(test));
            cf.thenRun(() -> System.out.println(a)) ;
        }
    }

    private static boolean doPost(String t) {
        System.out.println(t);

        return true;
    }
}

The actual code is a lot longer, as the doPost method will post some data to a web service. However, I'm able to replicate my issue with this bare-bones code.

I want to have the doPost method execute 100 times, but asynchronously for performance reasons (in order to push data to the web service faster than doing 100 synchronous calls would be).

In the code above, the ′doPost′ method is run a random amount of times, but always no more than 20-25 times. There are no exceptions thrown. It seems that either some thread handling mechanism is silently refusing to create new threads and execute their code, or the threads are silently crashing without crashing the program.

I also have an issue where, if I add more functionality to the doPost method than shown above, it reaches a point where the method simply silently breaks. I've tried adding a System.out.println("test") right before the return statement in that case, but it is never called. The loop which loops 100 times does run 100 iterations though.

This behaviour is confusing, to say the least.

What am I missing? Why is the function supplied as an argument to supplyAsync run a seemingly random number of times?

EDIT: Just wanted to point out that the situation is not exactly the same as in the question this was marked as a possible duplicate of, as that question dealt with arbitrarily deeply nested futures, and this one deals with parallell ones. However, the reason why they are failing is virtually identical. The cases seem distinct enough to merit separate questions to me, but others might disagree...

Answer 1

By default CompletableFuture uses own ForkJoinPool.commonPool() (see CompletableFuture implementation). And this default pool creates only daemon threads, e.g. they won't block the main application from terminating if they still alive.

You have the following choices:

1. Collect all CompletionStage to some array and then make java.util.concurrent.CompletableFuture#allOf().toCompletableFuture().join() - this will guarantee all the stages are completed before going after join()

2. Use *Async operations with your own thread pool which contains only non-daemon threads, like in the following example:

   public static void main(String[] args) throws InterruptedException {
       ExecutorService pool = Executors.newFixedThreadPool(10, r -> {
           Thread t = new Thread(r);
           t.setDaemon(false); // must be not daemon
           return t;
       });
   
       for (int i = 0; i < 100; i++) {
           final int a = i;
   
           // the operation must be Async with our thread pool
           CompletableFuture<Boolean> cf = CompletableFuture.supplyAsync(() -> doPost(a), pool);
           cf.thenRun(() -> System.out.printf("%s: Run_%s%n", Thread.currentThread().getName(), a));
       }
   
       pool.shutdown(); // without this the main application will be blocked forever
   }
   
   private static boolean doPost(int t) {
       System.out.printf("%s: Post_%s%n", Thread.currentThread().getName(), t);
   
       return true;
   }