【并发编程】多线程对任务的编排：CompletableFuture

CompletableFuture是什么

• 简单的任务，用Future获取结果还好，但我们并行提交的多个异步任务，往往并不是独立的，很多时候业务逻辑处理存在串行[依赖]、并行、聚合的关系。
• CompletableFuture是Future接口的扩展和增强。
• CompletableFuture实现了对任务的编排能力。
• 虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。

CompletableFuture的主要功能介绍

• 描述依赖关系：

• thenApply：把前面异步任务的结果，交给后面的Function
• thenCompose：用来连接两个有依赖关系的任务，结果由第二个任务返回

• 描述and聚合关系：

• thenCombine:任务合并，有返回值
• thenAccepetBoth:两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值。
• runAfterBoth:两个任务都执行完成后，执行下一步操作（Runnable）。

• 描述or聚合关系：

• applyToEither:两个任务谁执行的快，就使用那一个结果，有返回值。
• acceptEither: 两个任务谁执行的快，就消耗那一个结果，无返回值。
• runAfterEither: 任意一个任务执行完成，进行下一步操作(Runnable)。

• 并行执行：

• CompletableFuture类自己也提供了anyOf()和allOf()用于支持多个CompletableFuture并行执行

• 获取结果

• join:无异常抛出
• get：抛出的是经过检查的异常，ExecutionException, InterruptedException

• 结果处理

• whenComplete：正常的结果处理
• exceptionally:异常的结果处理
• whenCompleteAsync:正常的结果处理，开启新线程

• 结果转换

• thenApply:使用一阶段的结果用在二阶段，返回一个具有处理结果的Future对象。
• thenCompose:使用一阶段的结果用在二阶段，返回 CompletableFuture 实例的函数，该函数的参数是先前计算步骤的结果。

• 结果消费

• thenAccept系列：对单个结果进行消费
• thenAcceptBoth系列：对两个结果进行消费
• thenRun系列：不关心结果，只对结果执行Action

• 结果组合

• thenCombine:合并两个线程任务的结果，并进一步处理。

• 任务交互

• applyToEither:两个线程任务相比较，先获得执行结果的，就对该结果进行下一步的转化操作。返回CompletionStage<U>。
• acceptEither:两个线程任务相比较，先获得执行结果的，就对该结果进行下一步的消费操作。返回CompletionStage<Void>。
• runAfterEither：两个线程任务相比较，有任何一个执行完成，就进行下一步操作，不关心运行结果。返回CompletionStage<Void>。
• runAfterBoth：两个线程任务相比较，两个全部执行完成，才进行下一步操作，不关心运行结果。返回CompletionStage<Void>。
• anyOf：方法的参数是多个给定的 CompletableFuture，当其中的任何一个完成时，方法返回这个 CompletableFuture。
• allOf：方法用来实现多 CompletableFuture 的同时返回。

CompletableFuture的使用方式

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureTest {

	public static void main(String[] args) throws ExecutionException, InterruptedException {

		// 执行无返回结果的异步任务
		CompletableFuture.runAsync(() -> System.out.println("执行无返回结果的异步任务"));

		// 执行有返回值的异步任务
		CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
		    System.out.println("执行有返回值的异步任务");
		    try {
		        Thread.sleep(5000);
		    } catch (InterruptedException e) {
		        e.printStackTrace();
		    }
		    return "Hello World";
		});
		// 打印有返回值异步任务的返回值
		System.out.println(future.get());
	}
}

CompletableFuture的创建异步操作源码分析

/**
 * Supplier函数式接口类型为参数，有返回值，会阻塞
 */
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    return asyncSupplyStage(asyncPool, supplier);
}

/**
 * Supplier函数式接口类型和具体使用的线程池为参数，有返回值，会阻塞
 */
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                   Executor executor) {
    return asyncSupplyStage(screenExecutor(executor), supplier);
}

/**
 * 传入一个具体任务，执行的时候没有返回值！
 */
public static CompletableFuture<Void> runAsync(Runnable runnable) {
    return asyncRunStage(asyncPool, runnable);
}

/**
 * 传入一个具体任务和使用的线程池，执行的时候没有返回值
 */
public static CompletableFuture<Void> runAsync(Runnable runnable,
                                               Executor executor) {
    return asyncRunStage(screenExecutor(executor), runnable);
}

/**
 * 我们一般是多核处理器，如果不传入具体的线程池，则使用ForkJoinPool做为默认的线程池。
 */
private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

/**
 * 有返回值的具体创建方式
 */
static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
        Supplier<U> f) {
	// 传入的任务为null，抛异常
    if (f == null) throw new NullPointerException();
    // 创建一个CompletableFuture对象
    CompletableFuture<U> d = new CompletableFuture<U>();
    // 执行具体的任务：并通过CAS的方式设置结果
    e.execute(new AsyncSupply<U>(d, f));
    // 返回具体的结果
    return d;
}

/**
 * 无返回值的具体创建方式
 */
static CompletableFuture<Void> asyncRunStage(Executor e, Runnable f) {
    // 传入的任务weinull，抛异常
    if (f == null) throw new NullPointerException();
    // 创建一个CompletableFuture对象
    CompletableFuture<Void> d = new CompletableFuture<Void>();
    // 执行具体的任务：无任何设置结果的代码
    e.execute(new AsyncRun(d, f));
    // 返回具体的结果
    return d;
}

CompletableFuture的获取返回结果的方法join&get源码分析

/**
 * 获取结果的方法，不抛出异常
 */
public T join() {
    Object r;
    return reportJoin((r = result) == null ? waitingGet(false) : r);
}

/**
 * 抛出异常
 */
public T get() throws InterruptedException, ExecutionException {
    Object r;
    return reportGet((r = result) == null ? waitingGet(true) : r);
}

/**
 * join的获取方法
 */
private static <T> T reportJoin(Object r) {
    // 判断有没有异常，对各种异常进行判断并抛出
    if (r instanceof AltResult) {
        Throwable x;
        if ((x = ((AltResult)r).ex) == null)
            return null;
        if (x instanceof CancellationException)
            throw (CancellationException)x;
        if (x instanceof CompletionException)
            throw (CompletionException)x;
        throw new CompletionException(x);
    }
    // 强转并返回结果
    @SuppressWarnings("unchecked") T t = (T) r;
    return t;
}

/**
 * get的获取方法
 */
private static <T> T reportGet(Object r)
    throws InterruptedException, ExecutionException {
    // 结果不存在，抛异常
    if (r == null) // by convention below, null means interrupted
        throw new InterruptedException();
    // 判断有没有异常，对各种异常进行判断并抛出
    if (r instanceof AltResult) {
        Throwable x, cause;
        if ((x = ((AltResult)r).ex) == null)
            return null;
        if (x instanceof CancellationException)
            throw (CancellationException)x;
        if ((x instanceof CompletionException) &&
            (cause = x.getCause()) != null)
            x = cause;
        throw new ExecutionException(x);
    }
    // 强转并返回结果
    @SuppressWarnings("unchecked") T t = (T) r;
    return t;
}

/**
 * 等待获取最后的结果
 */
private Object waitingGet(boolean interruptible) {
    // Completion的子类，用于记录阻塞
    Signaller q = null;
    // 阻塞记录是否已放入任务栈中
    boolean queued = false;
    // 自旋的标志，-1代表未启动自旋，0代表已结束自旋，>0代表自旋进行中
    int spins = -1;
    // 具体返回的结果
    Object r;
    // 还没有结果的时候进入循环
    while ((r = result) == null) {
        // 自旋的标志小于0，说明未启动
        if (spins < 0)
            // private static final int SPINS = (Runtime.getRuntime().availableProcessors() > 1 ? 1 << 8 : 0);
            // 多核CPU这里的值是256，单核CPU的值为0
            spins = SPINS;
        // 自旋的标志大于0，说明正在自旋
        else if (spins > 0) {
            // 取一个随机数，看看要不要进行处理自旋次数
            if (ThreadLocalRandom.nextSecondarySeed() >= 0)
                --spins;
        }
        // 判断到这里，说明spins为0，准备进行阻塞
        // 阻塞队列中无内容的时候，进行创建队列
        else if (q == null)
            // 创建新的阻塞
            q = new Signaller(interruptible, 0L, 0L);
        // 不是第一次入队
        else if (!queued)
            // 入队操作
            queued = tryPushStack(q);
        // 判断当前的节点是否被中断
        else if (interruptible && q.interruptControl < 0) {
            // 取消线程的绑定
            q.thread = null;
            // 清楚队列中的当前节点
            cleanStack();
            // 返回结果为null
            return null;
        }
        // 还没有获取到结果
        else if (q.thread != null && result == null) {
            try {
                // 阻塞
                ForkJoinPool.managedBlock(q);
            } catch (InterruptedException ie) {
                // 阻塞中途出现问题，修改变量
                q.interruptControl = -1;
            }
        }
    }
    // 执行到这里说明获取到了值
    if (q != null) {
        // 释放线程
        q.thread = null;
        // 中断后的判断
        if (q.interruptControl < 0) {
            if (interruptible)
                r = null; // report interruption
            else
                Thread.currentThread().interrupt();
        }
    }
    // 将后续执行的任务唤醒。
    postComplete();
    // 返回具体的结果
    return r;
}

CompletableFuture的结果处理方法使用

import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.BiConsumer;
import java.util.function.Function;

public class CompletableFutureTest2 {

	public static void main(String[] args) throws ExecutionException, InterruptedException {

		CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if (new Random().nextInt(10) % 2 == 0) {
				System.out.println("出现异常！");
				int i = 12 / 0;
			}
			System.out.println("执行结束！");
			return "test";
		});

		future.whenComplete(new BiConsumer<String, Throwable>() {
			@Override
			public void accept(String t, Throwable action) {
				System.out.println(t + " 执行完成！");
			}
		});

		future.exceptionally(new Function<Throwable, String>() {
			@Override
			public String apply(Throwable t) {
				System.out.println("执行失败：" + t.getMessage());
				return "异常xxxx";
			}
		});
	}
}

结束语

• 获取更多本文的前置知识文章，以及新的有价值的文章，让我们一起成为架构师！
• 关注公众号，可以让你对MySQL、并发编程、spring源码有深入的了解！
• 关注公众号，后续持续高效的学习JVM！
• 这个公众号，无广告！！！每日更新！！！