java项目中，为主方案设计兜底方案

重要意义

优化算法的一个共同认知是：优化时间越长，优化性能越好。实际上，一方面我们期望算法都能给出全局最优解，另一个方面我们又对算法的执行时间有要求。
对于线上运行的许多需要即时响应的优化算法，都会设计兜底算法。兜底算法存在的重要意义在于，可以保证在固定时间内向系统返回结果，不至于出现超时或者系统崩溃的意外。相比主算法，兜底算法的性能优化能力可能会弱一些，但是响应速度和稳定性会明显更高。
举个例子，主算法使用精确求解算法，兜底算法使用启发式优化算法。精确算法全局优化能力强，但是计算时间无法保证；启发式算法速度快，但是往往只是一个局部最优解。如果时间允许，可以等待精确算法返回全局最优解；如果到了最大计算时间，精确算法仍未返回结果，则将启发式算法的解返回。

设计思路

还是使用上面的例子。主算法为精确算法，简称为算法A，A的结果更好，但是耗时更长；兜底算法为启发式算法，简称为算法B，B的耗时更短，但是结果略差。假设系统允许计算的时间为 $T_0$，整个框架的设计思路可以描述如下图

上图中，主算法和兜底算法并行计算。兜底算法B得到结果后，不会立即退出，会等待主算法的计算结果。如果A在$T_0$时间内可以返回结果，就使用A的结果；反之，使用B的结果。

实现过程

先上代码，如下

import java.util.concurrent.CompletableFuture;

public class MainAndBackupAlgo {

    // 主算法
    private static void mainSAlgo() throws InterruptedException {
        Thread.sleep(10);
    }

    // 兜底算法
    private static void backupAlgo() throws InterruptedException {
        Thread.sleep(5);
    }


    public static void main(String[] args) {

        // 主方案和兜底方案并行计算
        CompletableFuture<String> mainFuture = CompletableFuture.supplyAsync(() -> {
            // 主方案
            try {
                mainSAlgo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Main";
        });

        CompletableFuture<String> backupFuture = CompletableFuture.supplyAsync(() -> {
            // 兜底方案
            long startBackUpAlgorithm = System.currentTimeMillis();
            try {
                backupAlgo();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long endBackUpAlgorithm = System.currentTimeMillis();
            // 主方案的最大计算时间
            long maxCalculationTime = 20;
            if (endBackUpAlgorithm - startBackUpAlgorithm < maxCalculationTime){
                try {
                    Thread.sleep(maxCalculationTime - (endBackUpAlgorithm - startBackUpAlgorithm));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return "Backup";
        });

        // 获取最早输出的解
        CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(mainFuture, backupFuture);
        // 打印解的来源：maxCalculationTime为20时，输出Main；为3时，输出Backup
        System.out.println(anyOfFuture.join());

    }
}

算法并行使用CompletableFuture类。其使用方式可以参见CompletableFuture用法详解。CompletableFuture.anyOf()可以获取率先完成的任务结果。即，如果A在maxCalculationTime 内，可以得到解，使用A的结果，否则使用B的结果。