Demo

假設我們有 100 個任務，每個任務需要做大量 IO （用 sleep 10秒模擬）。

線程池實現

public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(8);
        List<Future> futures = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            final int count = i;
            Callable<Integer> callable = () -> {
                Thread.sleep(10000);
                return count;
            };
            Future future = executorService.submit(callable);
            futures.add(future);
        }

        System.out.println("start" + "  " + LocalDateTime.now().toString());

        Set<Future> finshed = new HashSet<>();
        while (finshed.size() < 100) {
            for (Future future : futures) {
                if (future.isDone() && !finshed.contains(future)) {
                    System.out.println(future.get() + "  " + LocalDateTime.now().toString());
                    finshed.add(future);
                }
            }
        }
    }

開 8 個線程並行。

結果：

可見，耗費時間爲 Math.ceil(100.0 / 8) * 10秒 : 130 秒。

start  2020-01-19T00:01:31.997
1  2020-01-19T00:01:41.978
2  2020-01-19T00:01:41.978
.......
99  2020-01-19T00:03:42.027

協程實現

<dependency>
            <groupId>co.paralleluniverse</groupId>
            <artifactId>quasar-core</artifactId>
            <version>0.7.10</version>
            <classifier>jdk8</classifier>
        </dependency>

public static void main(String[] args) throws Exception {
        List<Fiber<Integer>> fibers = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            final int count = i;
            Fiber<Integer> fiber = new Fiber<>((SuspendableCallable<Integer>) () -> {
                Fiber.sleep(100000);
                return count;
            });
            fiber.start();
            fibers.add(fiber);
        }

        for (Fiber fiber : fibers) {
            System.out.println(fiber.get() + "  " + LocalDateTime.now().toString());
        }
    }

看看有多少個線程，發現：多了：

1 個 FiberTimedScheduler-default-fiber-pool
8 個 ForkJoinPool-default-fiber-pool-worker

也就是說對於 100 個任務，協程只用了 8 個 worker 線程。（爲什麼不是 1 個 worker 線程呢？可參考：https://blog.csdn.net/justsomebody126/article/details/104022982。協程與線程之間時多對多，這也是爲了利用多 CPU 的特性。）

看輸出結果，可見：

100 個任務同時完成。也就是說 8 個 worker 線程，每個 worker 負責的 12 個任務不是串行的，這也就是協程的本質：
單線程實現並行。
對於 IO 佔時很長的任務來說，協程明顯非常有優勢。在同一個 Worker 線程中，如果當前任務遇到 IO，則把時間片讓出給其他任務。這也是爲什麼所有任務能夠同時完成。

0  2020-01-18T23:27:30.701
1  2020-01-18T23:27:30.702
2  2020-01-18T23:27:30.702
......
97  2020-01-18T23:27:30.706
98  2020-01-18T23:27:30.706
99  2020-01-18T23:27:30.706