1. 线程创建与启动的三种方式对比

三种创建方式的核心差异

Java 中创建并启动线程有三种常见方式，它们的本质区别在于任务如何定义以及线程如何被启动。无论哪种方式，最终都必须通过 Thread.start() 让 JVM 创建新线程并调用 run() 方法。

• 继承 Thread：把任务写在 run() 重写中，创建子类实例后直接 start()。缺点是 Java 单继承，任务无法再继承其他类。
• 实现 Runnable：把任务封装在 Runnable 对象中，交给 Thread 执行。任务与线程解耦，推荐优先使用。
• 实现 Callable + FutureTask：任务可以有返回值、可以抛出受检异常，通过 FutureTask 包装后仍由 Thread 启动，用 get() 获取结果。

完整可运行示例

下面代码分别用三种方式创建线程，每个线程打印自己的名称和序号，Callable 额外返回一个计算结果。运行后观察输出顺序和返回值。

import java.util.concurrent.*;

public class ThreadCreateDemo {

    // 方式一：继承 Thread
    static class MyThread extends Thread {
        private final int id;
        MyThread(int id) { this.id = id; }

        @Override
        public void run() {
            System.out.println("[继承Thread] " + getName() + " 执行, id=" + id);
        }
    }

    // 方式二：实现 Runnable
    static class MyRunnable implements Runnable {
        private final int id;
        MyRunnable(int id) { this.id = id; }

        @Override
        public void run() {
            System.out.println("[实现Runnable] " + Thread.currentThread().getName() + " 执行, id=" + id);
        }
    }

    // 方式三：实现 Callable
    static class MyCallable implements Callable<Integer> {
        private final int id;
        MyCallable(int id) { this.id = id; }

        @Override
        public Integer call() throws Exception {
            System.out.println("[实现Callable] " + Thread.currentThread().getName() + " 执行, id=" + id);
            return id * 100;  // 返回计算结果
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("=== 主线程开始 ===");

        // 方式一
        MyThread t1 = new MyThread(1);
        t1.setName("Thread-A");
        t1.start();

        // 方式二
        Thread t2 = new Thread(new MyRunnable(2), "Thread-B");
        t2.start();

        // 方式三
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable(3));
        Thread t3 = new Thread(futureTask, "Thread-C");
        t3.start();

        // 获取 Callable 返回值（阻塞直到 call() 执行完毕）
        Integer result = futureTask.get();
        System.out.println("Callable 返回值: " + result);

        System.out.println("=== 主线程结束 ===");
    }
}

运行结果与判读

一次典型运行输出如下（线程调度顺序可能不同）：

=== 主线程开始 ===
[继承Thread] Thread-A 执行, id=1
[实现Runnable] Thread-B 执行, id=2
[实现Callable] Thread-C 执行, id=3
Callable 返回值: 300
=== 主线程结束 ===

三种方式选择建议