import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class test {
    public static void main(String[] args) {
        String total = "";
        Callable<String> callable1 = new Callable<String>() {
            @Override
            public String call() throws Exception {
                String t1 = "";
                t1 = method1();
                return t1;
            }
        };
        Callable<String> callable2 = new Callable<String>() {
            @Override
            public String call() throws Exception {
                String t2 = method2();
                return t2;
            }
        };
        Callable<String> callable3 = new Callable<String>() {
            @Override
            public String call() throws Exception {
                String t3 = method3();
                return t3;
            }
        };
        List<Callable<String>> taskList = new ArrayList<Callable<String>>();
        taskList.add(callable1);
        taskList.add(callable2);
        taskList.add(callable3);
        ExecutorService executor = Executors.newFixedThreadPool(3);
        try {
            List<java.util.concurrent.Future<String>> futures = executor.invokeAll(taskList);
            for (java.util.concurrent.Future<String> future : futures) {
                total += future.get();
            }
            System.out.println(total);
        } catch (InterruptedException ie) {
            // do something if you care about interruption;
        } catch (java.util.concurrent.ExecutionException ee) {
            // handle exception if one of the tasks threw an exception
        }
        executor.shutdown();
    }
    public static String method1() {
        System.out.println("method1");
        return "1";
    }
    private static String method2() {
        System.out.println("method2");
        return "2";
    }
    private static String method3() {
        System.out.println("method3");
        return "3";
    }
}

List<Future<String>> futureList = executor.invokeAll(tasklist);
String result = futureList.get(0).get() +
                futureList.get(1).get() +
                futureList.get(2).get();

由于您的任务数量很少，您可以创建3个`CompletableFuture`，并在流中对其进行处理后合并。
    CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> method1());
    CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> method2());
    CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> method3());
 
    String concate = Stream.of(task1, task2, task3)
            .map(CompletableFuture::join)
            .reduce("", (s1, s2) -> s1 + s2);
    System.out.println(concate);

CompletableFuture<String> task1 = CompletableFuture.supplyAsync(Test::method1);
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(Test::method2);
CompletableFuture<String> task3 = CompletableFuture.supplyAsync(Test::method3);
String concat =
    Stream.of(task1, task2, task3).map(CompletableFuture::join).collect(Collectors.joining());
System.out.println(concat);