Examples of java.util.concurrent.CompletableFuture

java.util.concurrent.CompletableFuture

A {@link Future} that may be explicitly completed (setting itsvalue and status), and may be used as a {@link CompletionStage}, supporting dependent functions and actions that trigger upon its completion.

When two or more threads attempt to {@link #complete complete}, {@link #completeExceptionally completeExceptionally}, or {@link #cancel cancel}a CompletableFuture, only one of them succeeds.

In addition to these and related methods for directly manipulating status and results, CompletableFuture implements interface {@link CompletionStage} with the following policies:

Actions supplied for dependent completions of non-async methods may be performed by the thread that completes the current CompletableFuture, or by any other caller of a completion method.
All async methods without an explicit Executor argument are performed using the {@link ForkJoinPool#commonPool()}(unless it does not support a parallelism level of at least two, in which case, a new Thread is used). To simplify monitoring, debugging, and tracking, all generated asynchronous tasks are instances of the marker interface {@link AsynchronousCompletionTask}.
All CompletionStage methods are implemented independently of other public methods, so the behavior of one method is not impacted by overrides of others in subclasses.

CompletableFuture also implements {@link Future} with the followingpolicies:

Since (unlike {@link FutureTask}) this class has no direct control over the computation that causes it to be completed, cancellation is treated as just another form of exceptional completion. Method {@link #cancel cancel} has the same effect as{@code completeExceptionally(new CancellationException())}. Method {@link #isCompletedExceptionally} can be used to determine if aCompletableFuture completed in any exceptional fashion.
In case of exceptional completion with a CompletionException, methods {@link #get()} and {@link #get(long,TimeUnit)} throw an{@link ExecutionException} with the same cause as held in thecorresponding CompletionException. To simplify usage in most contexts, this class also defines methods {@link #join()} and{@link #getNow} that instead throw the CompletionException directlyin these cases.

@author Doug Lea @since 1.8

  @SuppressWarnings("unchecked")
  protected Object callFuture(AbstractAsyncProxyRemoteCall call, @SuppressWarnings("rawtypes") Class returnType) {
    // If the result value is a CompletableFuture then
    // we callCompletableAsync
    if (CompletableFuture.class.isAssignableFrom(returnType)) {
      @SuppressWarnings("rawtypes")
        CompletableFuture result = new CompletableFuture();
      callCompletableAsync(call, (r,hadException,exception) -> {
        if (hadException) result.completeExceptionally(exception);
        else result.complete(r);
      });
      // And return the CompletableFuture
      return result;
    }
    // Else if it's an IFuture then return


        // Because we want to test the absence of action in an async process, we forcibly repeat the server lookup
        // that just occurred so we can wait for it, and be sure that the scrubbed version of our own pledge was not
        // mistakenly added. Attempting to just test here without waiting would race, as the backend is processing
        // the reply we have above in parallel.
        CompletableFuture future = backend.refreshProjectStatusFromServer(project);
        gate.waitAndRun();
        sendServerStatus(httpReqs.take(), scrubbedPledge);
        future.get();
        assertEquals(0, gate.getTaskQueueSize());    // No pending set changes now.
        assertEquals(1, pledges.size());
        assertEquals(pledge, pledges.iterator().next());
    }

Examples of java.util.concurrent.CompletableFuture

Related Classes of java.util.concurrent.CompletableFuture