在當今高併發、高性能的系統開發中，多線程編程已經成為 Java 開發者必備的核心技能。無論是提高系統吞吐量、優化用户體驗，還是充分利用多核 CPU 資源，多線程技術都扮演着不可或缺的角色。本文作為 Java 多線程系列的開篇，將為你詳細講解多線程的基礎概念、應用場景以及實現方式。

1. 什麼是多線程？

線程是操作系統能夠進行運算調度的最小單位，也是程序執行流的最小單位。多線程就是指從單個進程中創建多個線程，這些線程可以併發執行不同的任務，共享進程的資源。

graph TD
    A[進程] --> B[線程1]
    A --> C[線程2]
    A --> D[線程3]
    B --- E[共享進程資源]
    C --- E
    D --- E

在 Java 中，通過創建 Thread 對象或實現 Runnable 接口可以實現多線程編程。每個線程都擁有自己的程序計數器、棧和局部變量，但共享堆內存和方法區。

2. 進程與線程的區別

理解多線程首先要明確進程與線程的區別：

3. 線程的生命週期

Java 線程在其生命週期中可能處於以下 6 種狀態之一：

• NEW：新創建但尚未啓動的線程
• RUNNABLE：可運行狀態，包括就緒和運行中
• BLOCKED：阻塞狀態，等待獲取鎖
• WAITING：等待狀態，無限期等待另一線程執行操作
• TIMED_WAITING：超時等待，有限期等待
• TERMINATED：終止狀態，線程執行完畢

stateDiagram-v2
    [*] --> NEW: 創建線程
    NEW --> RUNNABLE: start()
    RUNNABLE --> BLOCKED: 等待鎖
    BLOCKED --> RUNNABLE: 獲得鎖
    RUNNABLE --> WAITING: wait()/join()
    WAITING --> RUNNABLE: notify()/notifyAll()
    RUNNABLE --> TIMED_WAITING: sleep(time)/wait(time)
    TIMED_WAITING --> RUNNABLE: 時間到/notify()
    RUNNABLE --> TERMINATED: 執行完成
    TERMINATED --> [*]

理解線程狀態轉換對於多線程編程和問題診斷至關重要。

4. Java 多線程與操作系統線程的關係

Java 採用的是 1:1 線程模型，即一個 Java 線程對應一個操作系統原生線程。當創建一個 Java 線程時，JVM 會調用操作系統的 API 創建一個對應的原生線程。

graph TD
    A[Java應用] --> B[JVM]
    B --> C[Java線程1]
    B --> D[Java線程2]
    B --> E[Java線程3]
    C --- F[操作系統線程1]
    D --- G[操作系統線程2]
    E --- H[操作系統線程3]
    F --> I[CPU調度]
    G --> I
    H --> I

這種模型的優點是實現簡單、直接，缺點是線程創建和切換的開銷較大。Java 19 引入的虛擬線程(Virtual Thread)是一種更輕量級的實現，可大幅降低內存佔用（傳統線程約 1MB 內存，虛擬線程僅需幾 KB），特別適合高併發場景，如 Web 服務和大量 I/O 操作。

5. CPU 時間片輪轉機制

多線程執行並不是真正的"同時執行"，而是通過 CPU 的時間片輪轉機制實現的"看似同時"。

CPU 會為每個線程分配時間片，當一個線程的時間片用完，CPU 會保存線程的上下文（程序計數器、寄存器值等），然後切換到另一個線程繼續執行。由於 CPU 切換速度非常快，給人一種"同時執行"的錯覺。

gantt
    title CPU時間片輪轉
    dateFormat  s
    axisFormat %S

    線程1 :a1, 0, 2s
    線程2 :a2, after a1, 2s
    線程3 :a3, after a2, 2s
    線程1 :a4, after a3, 2s
    線程2 :a5, after a4, 2s

6. 並行 vs 併發

這是多線程中最容易混淆的概念：

• 併發(Concurrency)：多個任務在同一時間段內交替執行，單核 CPU 只能實現併發。
• 並行(Parallelism)：多個任務在同一時刻同時執行，需要多核 CPU 支持。

graph LR
    subgraph "併發（單核CPU）"
    A1[時間1] --> A2[線程A]
    A3[時間2] --> A4[線程B]
    A5[時間3] --> A6[線程A]
    end

    subgraph "並行（多核CPU）"
    B1[核心1] --> B2[線程A]
    B3[核心2] --> B4[線程B]
    end

併發與並行的代碼對比

併發示例（單線程模擬交替執行）：

public class ConcurrencyDemo {
    public static void main(String[] args) {
        // 單線程交替執行兩個任務
        for (int i = 0; i < 10; i++) {
            System.out.println("任務A: " + i);
            try {
                Thread.sleep(100); // 模擬切換到任務B
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            System.out.println("任務B: " + i);
        }
    }
}

輸出結果（任務 A 和任務 B 交替執行）：

任務A: 0
任務B: 0
任務A: 1
任務B: 1
...

並行示例（多線程同時執行）：

public class ParallelismDemo {
    public static void main(String[] args) {
        // 兩個線程並行執行任務
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("任務A: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("任務B: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        threadA.start();
        threadB.start();
    }
}

輸出結果（任務 A 和任務 B 同時執行，輸出交錯）：

任務A: 0
任務B: 0
任務A: 1
任務B: 1
任務B: 2
任務A: 2
...

實際輸出順序由 CPU 調度決定，每次運行可能不同，這也體現了多線程執行的不確定性，這也是多線程程序調試困難的原因之一。

7. Java 多線程的發展歷程

Java 多線程技術從誕生至今經歷了顯著的演變：

• Java 1.0：基礎的 Thread 類和 Runnable 接口
• Java 1.5：引入 java.util.concurrent (JUC)包，包含線程池、併發集合、原子類等
• Java 7：Fork/Join 框架，支持並行計算
• Java 8：Lambda 表達式簡化多線程代碼，CompletableFuture
• Java 9：增強的 CompletableFuture 和 Flow API
• Java 19(預覽)：Virtual Thread(虛擬線程)，提供輕量級線程實現，大幅減少內存佔用

8. 為什麼需要多線程？

多線程之所以如此重要，主要基於以下幾個原因：

8.1 提高資源利用率

單線程程序在執行 I/O 操作（如讀寫文件、網絡請求）時，CPU 會處於等待狀態：

gantt
    title 單線程 vs 多線程資源利用
    dateFormat  s
    axisFormat %S

    section 單線程
    CPU計算    :a1, 0, 1s
    等待I/O(CPU空閒)  :a2, after a1, 2s
    CPU計算    :a3, after a2, 1s

    section 多線程
    線程1-CPU計算  :b1, 0, 1s
    線程1-等待I/O  :b2, after b1, 2s
    線程2-CPU計算  :b3, 0, 3s
    線程1-CPU計算  :b4, after b2, 1s

多線程可以在一個線程等待 I/O 時，切換到另一個線程繼續使用 CPU，大幅提高資源利用率。

8.2 提升響應速度

在用户界面應用中，如果將耗時操作放在 UI 線程中執行，會導致界面卡頓：

• 單線程：UI 響應 → 耗時計算 → UI 響應（中間界面凍結）
• 多線程：UI 線程保持響應，耗時計算在後台線程執行

8.3 充分利用多核 CPU

現代計算機普遍配備多核 CPU，單線程程序只能使用其中一個核心：

• 單線程：只能使用一個 CPU 核心，其他核心閒置
• 多線程：可以將任務分配到多個核心並行處理，提高處理速度

測試表明，在四核 CPU 上，合理設計的並行計算可以獲得近 4 倍的性能提升。

9. 多線程的典型應用場景

9.1 高併發處理

場景：網站服務器同時處理成千上萬的請求。
解決方案：為每個請求分配一個線程或使用線程池處理請求。

// Tomcat服務器使用線程池處理HTTP請求
ExecutorService threadPool = Executors.newFixedThreadPool(100);
try {
    for (Request request : incomingRequests) {
        threadPool.execute(() -> {
            processRequest(request);
            generateResponse(request);
        });
    }
} finally {
    // 重要：關閉線程池，避免資源泄漏
    threadPool.shutdown();
    // 等待任務完成
    if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
        // 強制關閉
        threadPool.shutdownNow();
    }
}

9.2 任務並行處理

場景：大數據分析，需要處理大量數據。
解決方案：將數據分塊，多線程並行處理。

// 並行計算一個大數組的和
long[] array = new long[100000000];
// 填充數組...

// 分4個線程計算
int threadCount = 4;
Thread[] threads = new Thread[threadCount];
long[] results = new long[threadCount];
int segmentSize = array.length / threadCount;

for (int i = 0; i < threadCount; i++) {
    final int index = i;
    final int start = i * segmentSize;
    final int end = (i == threadCount - 1) ? array.length : (i + 1) * segmentSize;

    threads[i] = new Thread(() -> {
        long sum = 0;
        for (int j = start; j < end; j++) {
            sum += array[j];
        }
        results[index] = sum;
    });
    threads[i].start();
}

// 等待所有線程完成
for (Thread thread : threads) {
    try {
        thread.join();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // 恢復中斷狀態
        e.printStackTrace();
    }
}

// 合併結果
long finalSum = 0;
for (long result : results) {
    finalSum += result;
}

9.3 提高資源利用率

場景：應用程序需要執行 I/O 操作，如文件讀寫、網絡請求。
解決方案：使用多線程避免線程在等待 I/O 時空閒。

// 主線程繼續處理用户交互，另一線程處理文件下載
Thread downloadThread = new Thread(() -> {
    try {
        URL url = new URL("https://example.com/largefile.zip");
        try (InputStream in = url.openStream();
             FileOutputStream out = new FileOutputStream("largefile.zip")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
                // 更新下載進度...
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
});
downloadThread.start();

// 主線程繼續執行其他任務
processUserInteractions();

9.4 提升用户體驗

場景：GUI 應用中，執行耗時操作時保持界面響應。
解決方案：將耗時操作放在工作線程中執行，UI 線程保持響應。

// JavaFX示例
Button processButton = new Button("開始處理");
processButton.setOnAction(event -> {
    // 禁用按鈕，防止重複點擊
    processButton.setDisable(true);

    // 創建後台任務
    Thread bgThread = new Thread(() -> {
        try {
            // 耗時操作
            for (int i = 0; i < 100; i++) {
                final int progress = i;
                // 更新UI需要回到UI線程
                Platform.runLater(() -> progressBar.setProgress(progress / 100.0));
                Thread.sleep(100);
            }
            // 任務完成後啓用按鈕
            Platform.runLater(() -> processButton.setDisable(false));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }
    });

    // 啓動線程
    bgThread.start();
});

10. 線程創建的基本方式

Java 中創建線程主要有以下幾種方式：

10.1 繼承 Thread 類

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("線程 " + Thread.currentThread().getName() + " 正在執行");
    }
}

// 使用方式
MyThread thread = new MyThread();
thread.start(); // 啓動線程，會調用run()方法

10.2 實現 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("線程 " + Thread.currentThread().getName() + " 正在執行");
    }
}

// 使用方式
Thread thread = new Thread(new MyRunnable());
thread.start();

// 使用Lambda表達式（Java 8+）
Thread thread2 = new Thread(() -> {
    System.out.println("Lambda實現的線程正在執行");
});
thread2.start();

10.3 實現 Callable 接口（帶返回值）

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

// 創建實現Callable的類
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "線程執行結果";
    }
}

// 使用方式
FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();

// 獲取結果（會阻塞直到結果可用）
try {
    String result = futureTask.get();
    System.out.println("結果：" + result);
} catch (Exception e) {
    e.printStackTrace();
}

10.4 使用 Executor 框架（線程池）

直接創建大量線程會導致資源浪費，Executor 框架通過線程池重用線程，大幅降低創建和切換開銷：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 創建線程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任務
executor.execute(() -> {
    System.out.println("線程池中的線程執行任務");
});

// 使用完畢後關閉線程池
executor.shutdown();

Executor 框架是 Java 5 引入的更高級的線程創建和管理方式，提供了線程池、定時執行等功能。在下一篇文章中，我們將詳細介紹 Executor 框架的使用。

11. 實際案例：模擬銀行櫃枱服務

下面通過一個銀行櫃枱服務的例子，展示多線程如何提高系統處理能力：

import java.util.concurrent.TimeUnit;

public class BankCounterDemo {

    // 模擬客户處理
    static class CustomerHandler implements Runnable {
        private final String customerName;

        public CustomerHandler(String customerName) {
            this.customerName = customerName;
        }

        @Override
        public void run() {
            System.out.println("開始處理客户 " + customerName + " 的業務，線程：" + Thread.currentThread().getName());
            try {
                // 模擬業務處理時間
                Thread.sleep((int) (Math.random() * 5000) + 1000); // 1-6秒隨機時間
            } catch (InterruptedException e) {
                // 恢復中斷狀態
                Thread.currentThread().interrupt();
                System.out.println("客户 " + customerName + " 的業務處理被中斷");
                return;
            }
            System.out.println("客户 " + customerName + " 的業務處理完成，線程：" + Thread.currentThread().getName());
        }
    }

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

        // 模擬單線程處理10個客户
        if (args.length > 0 && args[0].equals("single")) {
            for (int i = 1; i <= 10; i++) {
                new CustomerHandler("客户" + i).run(); // 直接調用run方法，不創建新線程
            }
            System.out.println("單線程總耗時：" + (System.currentTimeMillis() - start) / 1000.0 + "秒");
            return;
        }

        // 模擬10個客户併發處理
        for (int i = 1; i <= 10; i++) {
            // 使用有意義的線程名稱，便於調試
            Thread customerThread = new Thread(new CustomerHandler("客户" + i), "櫃枱處理線程-" + i);
            customerThread.start();
        }

        // 主線程等待，讓我們能看到多線程執行情況
        try {
            Thread.sleep(15000); // 等待15秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }

        System.out.println("多線程總耗時：" + (System.currentTimeMillis() - start) / 1000.0 + "秒");
    }
}

單線程執行結果示例：

開始處理客户 客户1 的業務，線程：main
客户 客户1 的業務處理完成，線程：main
開始處理客户 客户2 的業務，線程：main
客户 客户2 的業務處理完成，線程：main
...
開始處理客户 客户10 的業務，線程：main
客户 客户10 的業務處理完成，線程：main
單線程總耗時：33.245秒

多線程執行結果示例：

開始處理客户 客户1 的業務，線程：櫃枱處理線程-1
開始處理客户 客户2 的業務，線程：櫃枱處理線程-2
開始處理客户 客户3 的業務，線程：櫃枱處理線程-3
開始處理客户 客户4 的業務，線程：櫃枱處理線程-4
開始處理客户 客户5 的業務，線程：櫃枱處理線程-5
開始處理客户 客户6 的業務，線程：櫃枱處理線程-6
開始處理客户 客户7 的業務，線程：櫃枱處理線程-7
開始處理客户 客户8 的業務，線程：櫃枱處理線程-8
開始處理客户 客户9 的業務，線程：櫃枱處理線程-9
開始處理客户 客户10 的業務，線程：櫃枱處理線程-10
客户 客户1 的業務處理完成，線程：櫃枱處理線程-1
客户 客户6 的業務處理完成，線程：櫃枱處理線程-6
...
多線程總耗時：15.006秒

分析：

1. 單線程處理方式下，10 個客户需要依次處理，總耗時約 33 秒
2. 多線程處理方式下，10 個客户併發處理，總耗時僅需約 15 秒
3. 多線程提升效率的核心在於資源並行使用，模擬現實中開設多個櫃枱同時服務

12. 多線程注意事項

12.1 避免過度使用多線程

線程創建和上下文切換都有開銷，過多的線程反而會降低系統性能：

1. 上下文切換開銷：CPU 在不同線程間切換時需要保存和恢復線程上下文，一次上下文切換開銷約為幾十到幾百納秒。如果系統中有 1000 個活躍線程頻繁切換，累積的開銷會非常可觀，甚至可能比單線程執行還慢數倍。
2. 內存開銷：每個線程需要佔用一定的內存空間（默認棧大小約 1MB）
3. 資源競爭：線程過多會導致嚴重的資源競爭

graph TD
    A["線程數量"] --> B["系統性能"]
    B --> C["過少：資源利用率低"]
    B --> D["適中：性能最優"]
    B --> E["過多：性能下降"]

12.2 線程安全問題

線程安全問題主要由三個因素共同導致：

1. 共享資源：多個線程同時訪問同一資源
2. 非原子操作：看似簡單的操作實際由多條指令組成
3. 內存可見性：線程對變量的修改對其他線程不可見
4. 指令重排序：編譯器和 CPU 可能重新排列指令執行順序

// 線程不安全的計數器示例
class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++;  // 看似是原子操作，實際包含讀取、遞增、寫入三步
    }

    public int getCount() {
        return count;
    }
}

在後續文章中，我們會詳細講解如何使用 synchronized、volatile、Lock、原子類等技術解決線程安全問題。

12.3 調試難度增加

多線程程序的執行順序不確定，這使得調試變得困難：

1. 問題可能難以重現
2. 日誌記錄順序混亂
3. 死鎖、飢餓等特殊問題難以排查

常用調試工具：

• jstack：查看線程棧信息，識別死鎖
• VisualVM：監控線程狀態、CPU 使用率
• JConsole：查看線程運行情況

12.4 線程命名規範

為線程設置有意義的名稱是多線程編程的一個重要實踐。線程命名有助於：

1. 在日誌中快速識別線程
2. 在線程轉儲(Thread Dump)中定位問題
3. 在調試過程中區分不同線程

// 不推薦：使用默認線程名
new Thread(runnable).start(); // 默認名稱為"Thread-0", "Thread-1"等

// 推薦：使用有意義的描述性名稱
new Thread(runnable, "訂單處理線程").start();
new Thread(runnable, "郵件發送線程-1").start();

// 或者設置線程名稱
Thread thread = new Thread(runnable);
thread.setName("數據導入線程-" + System.currentTimeMillis());
thread.start();

線程命名的良好實踐：

• 包含線程用途：如"訂單處理"、"HTTP 請求處理"
• 添加序號：如果有多個同類線程，添加序號區分
• 適當添加時間戳或其他標識：便於關聯日誌

13. 總結

通過本文，我們瞭解了 Java 多線程的基礎概念、應用場景和實現方式。多線程編程是 Java 中至關重要的一部分，掌握好多線程技術，將使你的應用程序更高效、更具響應性。

思考題

1. 為什麼count++在多線程環境中是不安全的？如何使用 java.util.concurrent.atomic 包中的原子類實現一個線程安全的計數器？
2. 在你的實際項目中，有哪些場景適合使用多線程技術？使用多線程可能帶來哪些性能提升？

在下一篇文章中，我們將深入探討線程創建的四種方式，包括 Callable+Future 實現帶返回值的線程以及 Executor 框架的使用。敬請期待！

如果覺得本文對你有幫助，別忘了點贊和收藏哦！