Java CompletableFuture.thenAcceptAsync方法代码示例

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

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
static <T> Future<T> toFuture(
        final CompletableFuture<T> completableFuture
) {
    final Future<T> future = Future.future();
    completableFuture.thenAcceptAsync(future::complete);
    return future;
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * Updates XConnect groups and flows for given key.
 *
 * @param key XConnect key
 * @param prevPorts previous XConnect ports
 * @param ports new XConnect ports
 */
private void updateXConnect(XConnectStoreKey key, Set<PortNumber> prevPorts,
        Set<PortNumber> ports) {
    // remove old filter
    prevPorts.stream().filter(port -> !ports.contains(port)).forEach(port -> {
        revokeFilter(key, ImmutableSet.of(port));
    });
    // install new filter
    ports.stream().filter(port -> !prevPorts.contains(port)).forEach(port -> {
        populateFilter(key, ImmutableSet.of(port));
    });

    CompletableFuture<ObjectiveError> fwdFuture = new CompletableFuture<>();
    CompletableFuture<ObjectiveError> nextFuture = new CompletableFuture<>();

    if (xConnectNextObjStore.containsKey(key)) {
        NextObjective nextObj = xConnectNextObjStore.get(key).value();
        revokeFwd(key, nextObj, fwdFuture);

        fwdFuture.thenAcceptAsync(fwdStatus -> {
            if (fwdStatus == null) {
                log.debug("Fwd removed. Now remove group {}", key);
                revokeNext(key, nextObj, nextFuture);
            }
        });

        nextFuture.thenAcceptAsync(nextStatus -> {
            if (nextStatus == null) {
                log.debug("Installing new group and flow for {}", key);
                populateFwd(key, populateNext(key, ports));
            }
        });
    } else {
        log.warn("NextObj for {} does not exist in the store.", key);
    }
}
 

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> CompletableFuture<Void> thenAccept
    (CompletableFuture<T> f, Consumer<? super T> a) {
    return f.thenAcceptAsync(a);
}