Java CompletableFuture.thenApplyAsync方法代码示例

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
CompletableFuture<Response> getResponseAsync(Executor executor) {
    CompletableFuture<Response> cf = pushCF.whenComplete((v, t) -> pushGroup.pushError(t));
    if(executor!=null && !cf.isDone()) {
        cf  = cf.thenApplyAsync( r -> r, executor);
    }
    return cf;
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Benchmark
public String mapConstN() throws InterruptedException, ExecutionException {
  CompletableFuture<String> f = constFuture;
  for (int i = 0; i < N.n; i++)
    f = f.thenApplyAsync(mapF);
  return f.get();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Benchmark
public String mapPromise() throws InterruptedException, ExecutionException {
  CompletableFuture<String> p = new CompletableFuture<String>();
  CompletableFuture<String> f = p.thenApplyAsync(mapF);
  p.complete(string);
  return f.get();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Benchmark
public String mapPromiseN() throws InterruptedException, ExecutionException {
  CompletableFuture<String> p = new CompletableFuture<String>();
  CompletableFuture<String> f = p;
  for (int i = 0; i < N.n; i++)
    f = f.thenApplyAsync(mapF);
  p.complete(string);
  return f.get();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Benchmark
public String setValueN() throws InterruptedException, ExecutionException {
  CompletableFuture<String> p = new CompletableFuture<>();
  CompletableFuture<String> f = p;
  for (int i = 0; i < N.n; i++)
    f = f.thenApplyAsync(mapF);
  p.complete(string);
  return f.get();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
private void fireClickEvent(ClickInventoryEvent e)
{
    Optional<Player> optional = Sponge.getServer().getPlayer(playerUniqueId);
    if (!optional.isPresent())
    {
        return;
    }
    Player player = optional.get();
    CompletableFuture<Boolean> future = CompletableFuture.completedFuture(Boolean.TRUE);
    for (SlotTransaction slotTransaction : e.getTransactions())
    {
        Slot slot = slotTransaction.getSlot();
        SlotIndex pos = SpongeUnimplemented.getSlotOrdinal(slot);
        if (SpongeUnimplemented.isSlotInInventory(slot, e.getTargetInventory()) && slotToListen.matches(pos))
        {
            e.setCancelled(true);
            boolean allowAction = actionIntervalManager.allowAction(player, acceptableActionIntervalTick);
            if (allowAction && itemsInSlots.containsKey(pos))
            {
                future = future.thenApplyAsync(p -> processClickEvent(e, player, pos) && p, executorService);
            }
        }
    }
    future.thenAccept(shouldKeepInventoryOpen ->
    {
        if (!shouldKeepInventoryOpen)
        {
            SpongeUnimplemented.closeInventory(player, plugin);
        }
    });
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
public static void main(String[] args) {

		System.out.printf("Main: Start\n");
		CompletableFuture<Integer> seedFuture = new CompletableFuture<>();
		Thread seedThread = new Thread(new SeedGenerator(seedFuture));
		seedThread.start();

		System.out.printf("Main: Getting the seed\n");
		int seed = 0;
		try {
			seed = seedFuture.get();
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
		System.out.printf("Main: The seed is: %d\n", seed);

		System.out.printf("Main: Launching the list of numbers generator\n");
		NumberListGenerator task = new NumberListGenerator(seed);
		CompletableFuture<List<Long>> startFuture = CompletableFuture.supplyAsync(task);

		System.out.printf("Main: Launching step 1\n");
		CompletableFuture<Long> step1Future = startFuture.thenApplyAsync(list -> {
			System.out.printf("%s: Step 1: Start\n", Thread.currentThread().getName());
			long selected = 0;
			long selectedDistance = Long.MAX_VALUE;
			long distance;
			for (Long number : list) {
				distance = Math.abs(number - 1000);
				if (distance < selectedDistance) {
					selected = number;
					selectedDistance = distance;
				}
			}
			System.out.printf("%s: Step 1: Result - %d\n", Thread.currentThread().getName(), selected);
			return selected;
		});

		System.out.printf("Main: Launching step 2\n");
		CompletableFuture<Long> step2Future = startFuture
				.thenApplyAsync(list -> list.stream().max(Long::compare).get());

		CompletableFuture<Void> write2Future = step2Future.thenAccept(selected -> {
			System.out.printf("%s: Step 2: Result - %d\n", Thread.currentThread().getName(), selected);
		});

		System.out.printf("Main: Launching step 3\n");
		NumberSelector numberSelector = new NumberSelector();
		CompletableFuture<Long> step3Future = startFuture.thenApplyAsync(numberSelector);

		System.out.printf("Main: Waiting for the end of the three steps\n");
		CompletableFuture<Void> waitFuture = CompletableFuture.allOf(step1Future, write2Future, step3Future);
		CompletableFuture<Void> finalFuture = waitFuture.thenAcceptAsync((param) -> {
			System.out.printf("Main: The CompletableFuture example has been completed.");
		});

		finalFuture.join();

	}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
public <T,U> CompletableFuture<U> thenApply
    (CompletableFuture<T> f, Function<? super T,U> a) {
    return f.thenApplyAsync(a);
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
public <T,U> CompletableFuture<U> thenApply
    (CompletableFuture<T> f, Function<? super T,U> a) {
    return f.thenApplyAsync(a, new ThreadExecutor());
}