JDK8中线程实现的本质与最佳实践指南

// Thread.java (JDK8源码节选)
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
        }
    }
}

// 三种方式的本质都是创建Thread对象并调用start()
// 方式1：继承Thread类
Thread thread1 = new CustomThread();  // CustomThread extends Thread
thread1.start();
// 方式2：实现Runnable接口
Runnable runnable = new CustomRunnable();  // CustomRunnable implements Runnable
Thread thread2 = new Thread(runnable);
thread2.start();
// 方式3：实现Callable接口（间接）
Callable<String> callable = new CustomCallable();  // CustomCallable implements Callable
FutureTask<String> futureTask = new FutureTask<>(callable);
Thread thread3 = new Thread(futureTask);  // FutureTask实现了RunnableFuture，而RunnableFuture继承了Runnable
thread3.start();

// Thread类的简化继承关系
public class Thread implements Runnable {
    // 线程状态、优先级、栈大小等属性
    // 大量native方法：start0(), stop0(), sleep0()等
    
    // 关键：Thread本身就是一个Runnable
}

// 场景1：继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承方式");
    }
}
// 执行流程：
// 1. 创建MyThread实例
// 2. 调用start() → 创建系统线程 → 调用run()
// 3. 由于重写了run()，直接执行自定义逻辑
// 场景2：实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable方式");
    }
}
// 执行流程：
// 1. 创建Thread实例，传入MyRunnable
// 2. 调用start() → 创建系统线程 → 调用Thread.run()
// 3. Thread.run()检查target不为null → 调用target.run()
// 4. 执行MyRunnable的run()方法

// 问题场景：需要继承业务类，又想拥有线程能力
class BusinessService {
    public void doBusiness() {
        // 业务逻辑
    }
}
// 错误示例：无法同时继承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. 下载逻辑（业务职责）
        // 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() {
        // 仅关注下载业务逻辑
        downloadFile(url, savePath);
    }
    private void downloadFile(String url, String savePath) {
        // 具体的下载实现
    }
}
// 线程管理与业务逻辑分离
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();
// 所有线程执行完毕后，共享的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("任务执行中");
    }
});
// 使用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();  // 委托执行实际任务
        long end = System.currentTimeMillis();
        System.out.println("任务结束，耗时: " + (end - start) + "ms");
    }
}
// 使用装饰器模式增强功能
Runnable coreTask = () -> {
    // 核心业务逻辑
    System.out.println("执行核心业务");
};
Runnable enhancedTask = new LoggingRunnable(coreTask);
// 执行增强后的任务
Thread thread = new Thread(enhancedTask);
thread.start();
// 输出：
// 任务开始: Thread-0
// 执行核心业务
// 任务结束，耗时: Xms

// Thread对象 vs Runnable对象的内存对比
// Thread对象包含：
// 1. 线程栈（默认1MB）
// 2. 程序计数器
// 3. 本地方法栈
// 4. 线程状态、优先级等大量字段
// Runnable实现类：
// 1. 仅包含业务相关字段
// 2. 通常更轻量
// 场景：需要创建大量任务时
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对象