How to enforce timeout and cancel async CompletableFuture Jobs

I am using Java 8, and I want to know the recommended way to enforce timeout on 3 async jobs that I would to execute async and retrieve the result from the future. Note that the timeout is the same for all 3 jobs. I also want to cancel the job if it goes beyond time limit.

I am thinking something like this:

// Submit jobs async
List<CompletableFuture<String>> futures = submitJobs(); // Uses CompletableFuture.supplyAsync

List<CompletableFuture<Void>> all = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));

try {
    allFutures.get(100L, TimeUnit.MILLISECONDS);
} catch (TimeoutException e){
   for(CompletableFuture f : future) {
      if(!f.isDone()) {
         /*
         From Java Doc:
         @param mayInterruptIfRunning this value has no effect in this
             * implementation because interrupts are not used to control
             * processing.
         */
         f.cancel(true);
      }
   }
}

List<String> output = new ArrayList<>();
for(CompeletableFuture fu : futures) {
   if(!fu.isCancelled()) { // Is this needed?
      output.add(fu.join());
   }
}

return output;

1. Will something like this work? Is there a better way?
2. How to cancel the future properly? Java doc says, thread cannot be interrupted? So, if I were to cancel a future, and call join(), will I get the result immediately since the thread will not be interrupted?
3. Is it recommended to use join() or get() to get the result after waiting is over?

It is worth noting that calling cancel on CompletableFuture is effectively the same as calling completeExceptionally on the current stage. The cancellation will not impact prior stages. With that said:

1. In principle, something like this will work assuming upstream cancellation is not necessary (from a pseudocode perspective, the above has syntax errors).
2. CompletableFuture cancellation will not interrupt the current thread. Cancellation will cause all downstream stages to be triggered immediately with a CancellationException (will short circuit the execution flow).
3. 'join' and 'get' are effectively the same in the case where the caller is willing to wait indefinitely. Join handles wrapping the checked Exceptions for you. If the caller wants to timeout, get will be needed.

Including a segment to illustrate the behavior on cancellation. Note how downstream processes will not be started, but upstream processes continue even after cancellation.

    public static void main(String[] args) throws Exception
	{
		int maxSleepTime = 1000;
		Random random = new Random();
		AtomicInteger value = new AtomicInteger();
		List<String> calculatedValues = new ArrayList<>();
		Supplier<String> process = () -> { try { Thread.sleep(random.nextInt(maxSleepTime)); System.out.println("Stage 1 Running!"); } catch (InterruptedException e) { e.printStackTrace(); } return Integer.toString(value.getAndIncrement()); };
		List<CompletableFuture<String>> stage1 = IntStream.range(0, 10).mapToObj(val -> CompletableFuture.supplyAsync(process)).collect(Collectors.toList());
		List<CompletableFuture<String>> stage2 = stage1.stream().map(Test::appendNumber).collect(Collectors.toList());
		List<CompletableFuture<String>> stage3 = stage2.stream().map(Test::printIfCancelled).collect(Collectors.toList());
		CompletableFuture<Void> awaitAll = CompletableFuture.allOf(stage2.toArray(new CompletableFuture[0]));
		try
		{
			/*Wait 1/2 the time, some should be complete. Some not complete -> TimeoutException*/
			awaitAll.get(maxSleepTime / 2, TimeUnit.MILLISECONDS);
		}
		catch(TimeoutException ex)
		{
			for(CompletableFuture<String> toCancel : stage2)
			{
				boolean irrelevantValue = false;
				if(!toCancel.isDone())
					toCancel.cancel(irrelevantValue);
				else
					calculatedValues.add(toCancel.join());
			}
		}
		System.out.println("All futures Cancelled! But some Stage 1's may still continue printing anyways.");
		System.out.println("Values returned as of cancellation: " + calculatedValues);
		Thread.sleep(maxSleepTime);
	}

	private static CompletableFuture<String> appendNumber(CompletableFuture<String> baseFuture) 
	{
		return baseFuture.thenApply(val -> {  System.out.println("Stage 2 Running"); return "#" + val; }); 
	}
	
	private static CompletableFuture<String> printIfCancelled(CompletableFuture<String> baseFuture) 
	{ 
		return baseFuture.thenApply(val ->  { System.out.println("Stage 3 Running!"); return val; }).exceptionally(ex -> { System.out.println("Stage 3 Cancelled!"); return ex.getMessage(); }); 
	}

If it is necessary to cancel the upstream process (ex: cancel some network call), custom handling will be needed.

After calling cancel you cannot join the furure, since you get an exception.

One way to terminate the computation is to let it have a reference to the future and check it periodically: if it was cancelled abort the computation from inside.
This can be done if the computaion is a loop where at each iteration you can do the check.

Do you need it to be a CompletableFuture? Cause another way is to avoid to use a CompleatableFuture, and use a simple Future or a FutureTask instead: if you execute it with an Executor calling future.cancel(true) will terminate the computation if possbile.

Answerring to the question: "call join(), will I get the result immediately".

No you will not get it immediately, it will hang and wait to complete the computation: there is no way to force a computation that takes a long time to complete in a shorter time.

You can call future.complete(value) providing a value to be used as default result by other threads that have a reference to that future.