理解 CompletableFuture 的任务与回调函数的线程

1public static CompletableFuture<Void> runAsync(Runnable runnable) {
2    return asyncRunStage(asyncPool, runnable);
3}

 1private static final boolean useCommonPool =
 2    (ForkJoinPool.getCommonPoolParallelism() > 1);
 3
 4/**
 5 * Default executor -- ForkJoinPool.commonPool() unless it cannot
 6 * support parallelism.
 7 */
 8private static final Executor asyncPool = useCommonPool ?
 9    ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
10
11/** Fallback if ForkJoinPool.commonPool() cannot support parallelism */
12static final class ThreadPerTaskExecutor implements Executor {
13    public void execute(Runnable r) { new Thread(r).start(); }
14    

1public CompletableFuture<Void> thenRunAsync(Runnable action) {
2    return uniRunStage(asyncPool, action); 

 1package cc.unmi;
 2
 3import java.util.concurrent.CompletableFuture;
 4import java.util.concurrent.CompletionStage;
 5import java.util.concurrent.ExecutorService;
 6import java.util.concurrent.Executors;
 7
 8public class Main {
 9
10    public static void main(String[] args) {
11        System.out.println("main thread: " + Thread.currentThread());
12
13        new Thread(Main::test1) {{
14            setName("my-new-thread");
15        }}.start();
16
17        test2();
18    }
19
20    private static void test1() {
21
22        CompletionStage<Void> futurePrice = CompletableFuture.runAsync(() -> {
23                sleep(1000);
24                System.out.println("test1:1 - runAsync(runnable), job thread: " + Thread.currentThread());
25            }
26        );
27
28        System.out.println("test1:flag1");
29
30        futurePrice.thenRun(() -> {
31            System.out.println("test1:2 - thenRun(runnable)), action thread: " + Thread.currentThread());
32        });
33
34        System.out.println("test1:flag2");
35
36        futurePrice.thenRunAsync(() -> {
37            System.out.println("test1:3 - thenRunAsync(runnable), action thread: " + Thread.currentThread());
38        });
39
40    }
41
42
43    private static void test2() {
44
45        ExecutorService executorService = Executors.newCachedThreadPool();
46        CompletionStage<Void> futurePrice = CompletableFuture.runAsync(() -> {
47            sleep(1000);
48            System.out.println("test2:1 - runAsync(runnable, executor), job thread: " + Thread.currentThread());
49        }, executorService);
50
51        System.out.println("test2:flag1");
52
53        futurePrice.thenRunAsync(() -> {
54            System.out.println("test2:2 - thenRunAsync(runnable), action thread: " + Thread.currentThread());
55        });
56
57        System.out.println("test2:flag2");
58
59        futurePrice.thenRun(() -> {
60            System.out.println("test2:3 - thenRun(runnable), action thread: " + Thread.currentThread());
61        });
62
63        futurePrice.thenRunAsync(() -> {
64            System.out.println("test2:4 - thenRunAsync(runnable, executor), action thread: " + Thread.currentThread());
65        }, executorService);
66
67        executorService.shutdown();
68    }
69
70    private static void sleep(long time) {
71        //if(true) return;
72        try {
73            Thread.sleep(time);
74        } catch (InterruptedException e) {
75        }
76    }
77}