多執行緒的相關術語

序列（串行）：任務依照先後順序逐一執行，必須等前一個任務完成後，下一個任務才會開始執行。
並發（交替執行）：多個任務在同一單位時間內交替執行，從宏觀上看似乎同時進行，但在任何特定時刻，實際上僅有一個任務在執行。這種模式通常發生在單核心或單執行緒環境下。
平行（真正同時執行）：多個任務能夠在相同時刻真正地同時運行，這通常依賴於多核心處理器或多處理器系統，使得各任務可分派到不同的核心上同步執行。

1. 序列（串行）

所有任務按順序執行，一個完成後才開始下一個。

程式碼

public class SequentialExample {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

        task("Task 1");
        task("Task 2");
        task("Task 3");

        long endTime = System.currentTimeMillis();
        System.out.println("Total time: " + (endTime - startTime) + "ms");
    }

    static void task(String name) {
        System.out.println(name + " started");
        try {
            Thread.sleep(1000); // 模擬 1 秒執行時間
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + " finished");
    }
}

輸出

Task 1 started
Task 1 finished
Task 2 started
Task 2 finished
Task 3 started
Task 3 finished
Total time: 3000ms

分析：

每個任務按順序執行，執行時間約 3s，因為它們是 串行（同步） 的。

2. 並發（交替執行）

使用 ExecutorService 和 Future 來模擬 並發（但仍然是單執行緒交替運行）。

程式碼

import java.util.concurrent.*;

public class ConcurrentExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(1); // 單一執行緒（模擬並發交替）

        Future<?> task1 = executor.submit(() -> task("Task 1"));
        Future<?> task2 = executor.submit(() -> task("Task 2"));
        Future<?> task3 = executor.submit(() -> task("Task 3"));

        task1.get();
        task2.get();
        task3.get();

        executor.shutdown();
    }

    static void task(String name) {
        System.out.println(name + " started");
        try {
            Thread.sleep(1000); // 模擬 1 秒執行時間
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + " finished");
    }
}

輸出（但可能順序不同）

Task 1 started
Task 1 finished
Task 2 started
Task 2 finished
Task 3 started
Task 3 finished

分析：

這裡用 單一執行緒池（FixedThreadPool(1)），所以雖然 任務是並發提交的，但仍然是 交替運行（不是並行）。

3. 平行（真正同時執行）

使用 多執行緒（ExecutorService 的 FixedThreadPool） 來模擬 真正的並行運行。

程式碼

import java.util.concurrent.*;

public class ParallelExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3); // 3 個執行緒同時執行

        executor.execute(() -> task("Task 1"));
        executor.execute(() -> task("Task 2"));
        executor.execute(() -> task("Task 3"));

        executor.shutdown();
        executor.awaitTermination(5, TimeUnit.SECONDS);
    }

    static void task(String name) {
        System.out.println(name + " started on " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000); // 模擬 1 秒執行時間
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + " finished on " + Thread.currentThread().getName());
    }
}

輸出（順序可能不同）

Task 1 started on pool-1-thread-1
Task 2 started on pool-1-thread-2
Task 3 started on pool-1-thread-3
Task 1 finished on pool-1-thread-1
Task 2 finished on pool-1-thread-2
Task 3 finished on pool-1-thread-3

分析：

這次我們用了 3 個執行緒，所以任務 真正同時執行（並行），總執行時間約 1 秒，比起並發或串行方式快了 3 倍。

總結

類型	方式	特性	例子
序列（串行）	單執行緒，順序執行	需要等前一個完成才能開始下一個	`main()` 內部依序呼叫 `task()`
並發（交替執行）	多任務交替運行，但仍是單執行緒	交替執行，非真正同時進行	`ExecutorService.newFixedThreadPool(1)`
平行（真正同時執行）	多個執行緒同時執行	需要多核心 CPU，真正並行	`ExecutorService.newFixedThreadPool(3)`