Java 多線程編程基石：繼承 Thread 與實現 Runnable 的核心差異與選型指南

Java 提供兩種創建線程的基本方式：繼承 java.lang.Thread 類與實現 java.lang.Runnable 接口。雙方均需重寫 run() 方法定義執行邏輯，但在繼承關係、資源共享、設計靈活性、線程池適配等方面存在本質差異。本文通過源碼級分析與實戰對比，給出明確選型建議。

方式一：繼承 Thread 類

class MyThread extends Thread {
    private final String name;
    private final int iterations;
    private final int sleepMs;

    public MyThread(String name, int iterations, int sleepMs) {
        this.name = name;
        this.iterations = iterations;
        this.sleepMs = sleepMs;
    }

    @Override
    public void run() {
        System.out.println(name + " 開始運行，迭代 " + iterations + " 次，間隔 " + sleepMs + "ms");
        for (int i = 0; i < iterations; i++) {
            System.out.println(name + " -> " + i);
            try { Thread.sleep(sleepMs); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; }
        }
        System.out.println(name + " 結束");
    }
}

// 使用
new MyThread("Thread-A", 5, 200).start();
new MyThread("Thread-B", 3, 500).start();

特點

• 優點：代碼直觀，this 即線程對象，調用 getName()、sleep()、interrupt() 等 Thread 方法無需轉型
• 缺點：
  • 單繼承限制：已繼承其他類無法使用
  • 線程對象與任務耦合：每個任務需創建新 Thread 實例，難以復用
  • 不適配線程池：ExecutorService.execute() 接收 Runnable，傳入 Thread 會被當作任務在調用線程中直接運行 run()，而非新線程

方式二：實現 Runnable 接口（推薦）

class MyTask implements Runnable {
    private final String name;
    private final int iterations;
    private final int sleepMs;

    public MyTask(String name, int iterations, int sleepMs) {
        this.name = name;
        this.iterations = iterations;
        this.sleepMs = sleepMs;
    }

    @Override
    public void run() {
        // 邏輯同前
        Thread current = Thread.currentThread(); // 獲取當前執行線程
        System.out.println(name + " 在線程 " + current.getName() + " 中運行");
        for (int i = 0; i < iterations; i++) {
            System.out.println(name + " -> " + i);
            try { Thread.sleep(sleepMs); } catch (InterruptedException e) { current.interrupt(); break; }
        }
    }
}

// 多種啟動方式
Runnable task = new MyTask("Task-1", 5, 200);
new Thread(task, "Worker-1").start();           // 直接新線程
new Thread(task, "Worker-2").start();           // 同一任務實例多線程並發運行 (共享數據需同步)
executorService.submit(task);                   // 線程池執行
completableFuture.runAsync(task);               // 異步編排

核心優勢

1. 任務與線程解耦：同一 Runnable 實例可提交給多個線程/線程池並發執行
2. 支持函數式編程：Java 8+ Lambda 表達式 () -> { ... } 直接作為 Runnable
3. 完美適配高級併發 API：ExecutorService、CompletableFuture、ThreadFactory、ScheduledExecutorService
4. 無單繼承限制：類可繼承業務基類同時實現 Runnable

深度對比表

進階：Callable + Future 獲取返回值

若任務需返回結果或拋出受檢異常，使用 Callable：

Callable callable = () -> {
    Thread.sleep(1000);
    return "結果數據";
};
Future future = executorService.submit(callable);
String result = future.get(); // 阻塞獲取結果

源碼視角：Thread.run() 默認實現

// java.lang.Thread
@Override
public void run() {
    if (target != null) { // target 是 Runnable
        target.run();
    }
}

可見 Thread 本質上是 Runnable 的包裝器與執行載體。繼承 Thread 重寫 run() 實際上是繞過了 target，而實現 Runnable 則是標準的委託模式。

最佳實踐總結

1. 默認選擇 Runnable (或 Lambda)：解耦任務邏輯與執行策略
2. 統一使用線程池 (ExecutorService)：控制並發度、複用線程、管理生命周期、異常處理
3. 避免手動 new Thread()：除非極簡單的一次性後台任務且生命周期極短
4. 需返回值用 Callable + Future/CompletableFuture
5. 定時任務用 ScheduledExecutorService：替代 Timer
6. 線程命名規範：new Thread(task, "Business-Worker-%d") 便於排查

理解 Thread 是「執行者」，Runnable 是「任務」，將二者職責分離，是編寫可維護、可擴展、高性能 Java 併發程序的起點。