// Thread.java (JDK8源碼節(jié)選)
public class Thread implements Runnable {
    private Runnable target;
    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    @Override
    public void run() {
        if (target != null) {
            target.run();  // 調用傳遞的Runnable
        }
    }
}

// 三種方式的本質都是創(chuàng)建Thread對象并調用start()
// 方式1：繼承Thread類
Thread thread1 = new CustomThread();  // CustomThread extends Thread
thread1.start();
// 方式2：實現(xiàn)Runnable接口
Runnable runnable = new CustomRunnable();  // CustomRunnable implements Runnable
Thread thread2 = new Thread(runnable);
thread2.start();
// 方式3：實現(xiàn)Callable接口（間接）
Callable<String> callable = new CustomCallable();  // CustomCallable implements Callable
FutureTask<String> futureTask = new FutureTask<>(callable);
Thread thread3 = new Thread(futureTask);  // FutureTask實現(xiàn)了RunnableFuture，而RunnableFuture繼承了Runnable
thread3.start();

// Thread類的簡化繼承關系
public class Thread implements Runnable {
    // 線程狀態(tài)、優(yōu)先級、棧大小等屬性
    // 大量native方法：start0(), stop0(), sleep0()等
    
    // 關鍵：Thread本身就是一個Runnable
}

// 場景1：繼承Thread類
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("繼承方式");
    }
}
// 執(zhí)行流程：
// 1. 創(chuàng)建MyThread實例
// 2. 調用start() → 創(chuàng)建系統(tǒng)線程 → 調用run()
// 3. 由于重寫了run()，直接執(zhí)行自定義邏輯
// 場景2：實現(xiàn)Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable方式");
    }
}
// 執(zhí)行流程：
// 1. 創(chuàng)建Thread實例，傳入MyRunnable
// 2. 調用start() → 創(chuàng)建系統(tǒng)線程 → 調用Thread.run()
// 3. Thread.run()檢查target不為null → 調用target.run()
// 4. 執(zhí)行MyRunnable的run()方法

// 問題場景：需要繼承業(yè)務類，又想擁有線程能力
class BusinessService {
    public void doBusiness() {
        // 業(yè)務邏輯
    }
}
// 錯誤示例：無法同時繼承Thread
// class BusinessThread extends BusinessService, Thread { } // 編譯錯誤
// 正確方案：使用Runnable
class BusinessThread extends BusinessService implements Runnable {
    @Override
    public void run() {
        // 線程邏輯
        doBusiness();
    }
}
// 使用
Thread thread = new Thread(new BusinessThread());
thread.start();

// 不良設計：Thread子類承擔多重職責
class DownloadThread extends Thread {
    private String url;
    private String savePath;
    public DownloadThread(String url, String savePath) {
        this.url = url;
        this.savePath = savePath;
    }
    @Override
    public void run() {
        // 1. 下載邏輯（業(yè)務職責）
        // 2. 線程調度（線程職責）
    }
}
// 良好設計：職責分離
class DownloadTask implements Runnable {
    private String url;
    private String savePath;
    public DownloadTask(String url, String savePath) {
        this.url = url;
        this.savePath = savePath;
    }
    @Override
    public void run() {
        // 僅關注下載業(yè)務邏輯
        downloadFile(url, savePath);
    }
    private void downloadFile(String url, String savePath) {
        // 具體的下載實現(xiàn)
    }
}
// 線程管理與業(yè)務邏輯分離
Thread downloadThread = new Thread(new DownloadTask("http://example.com/file", "/path/to/save"));
downloadThread.start();

// 場景：多個線程處理同一共享資源
class CounterTask implements Runnable {
    private int count = 0;
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            synchronized (this) {
                count++;
            }
        }
    }
    public int getCount() {
        return count;
    }
}
// 共享同一個Runnable實例
CounterTask sharedTask = new CounterTask();
// 多個線程共享同一任務對象
Thread thread1 = new Thread(sharedTask, "Thread-1");
Thread thread2 = new Thread(sharedTask, "Thread-2");
Thread thread3 = new Thread(sharedTask, "Thread-3");
thread1.start();
thread2.start();
thread3.start();
// 所有線程執(zhí)行完畢后，共享的count是3000

// 如果繼承Thread，每個線程有自己的count實例
class CounterThread extends Thread {
    private int count = 0;  // 每個線程獨立實例
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            synchronized (this) {
                count++;
            }
        }
    }
}
// 每個線程有獨立的count，無法共享
CounterThread t1 = new CounterThread();
CounterThread t2 = new CounterThread();
// t1和t2的count是獨立的

import java.util.concurrent.*;
// Runnable與Executor框架完美配合
ExecutorService executor = Executors.newFixedThreadPool(5);
// 提交Runnable任務
executor.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("任務執(zhí)行中");
    }
});
// 使用Lambda表達式簡化（JDK8）
executor.submit(() -> System.out.println("Lambda任務"));
// 而Thread對象無法直接提交給Executor
// executor.submit(new MyThread()); // 可以但不推薦，因為Thread也是Runnable
// 問題：Thread的start()方法只能調用一次，線程池會重復調用run()而非start()

// 使用Runnable可以靈活組合功能
class LoggingRunnable implements Runnable {
    private final Runnable delegate;
    public LoggingRunnable(Runnable delegate) {
        this.delegate = delegate;
    }
    @Override
    public void run() {
        long start = System.currentTimeMillis();
        System.out.println("任務開始: " + Thread.currentThread().getName());
        delegate.run();  // 委托執(zhí)行實際任務
        long end = System.currentTimeMillis();
        System.out.println("任務結束，耗時: " + (end - start) + "ms");
    }
}
// 使用裝飾器模式增強功能
Runnable coreTask = () -> {
    // 核心業(yè)務邏輯
    System.out.println("執(zhí)行核心業(yè)務");
};
Runnable enhancedTask = new LoggingRunnable(coreTask);
// 執(zhí)行增強后的任務
Thread thread = new Thread(enhancedTask);
thread.start();
// 輸出：
// 任務開始: Thread-0
// 執(zhí)行核心業(yè)務
// 任務結束，耗時: Xms

// Thread對象 vs Runnable對象的內存對比
// Thread對象包含：
// 1. 線程棧（默認1MB）
// 2. 程序計數器
// 3. 本地方法棧
// 4. 線程狀態(tài)、優(yōu)先級等大量字段
// Runnable實現(xiàn)類：
// 1. 僅包含業(yè)務相關字段
// 2. 通常更輕量
// 場景：需要創(chuàng)建大量任務時
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    threads.add(new MyThread());  // 每個Thread對象約1MB棧內存
}
// 總內存：~1000MB
List<Runnable> tasks = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    tasks.add(new MyRunnable());  // 每個Runnable對象很小
}
// 使用線程池管理，只需少量Thread對象