Java四种线程创建方式

一句话先给你总览（先建立大脑地图）

Java 创建线程 = 两大类 + 四种方式

|----------------|----------------------------|
| 分类 | 方式 |
| 直接创建线程 | ① 继承 Thread |
| | ② 实现 Runnable |
| "高级"线程（推荐） | ③ 实现 Callable + Future |
| | ④ 线程池 ExecutorService |

一、方式 ①：继承 Thread（最直观，但不推荐）

1.核心思想

线程 = 一个类
任务写在 **run()**里

2.代码（你必须记住这个结构）

java 复制代码

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

public class Test {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start(); // ❗必须是 start()
    }
}

3.必须牢记的 2 个坑（面试 & 实战必考）

不能调用 run()

java 复制代码

t.run(); // 这不是多线程，只是普通方法调用

必须调用

java 复制代码

t.start(); // JVM 创建新线程

Java 只能单继承

java 复制代码

class A extends Thread extends B // ❌ 不可能

4.什么时候用？

学习
Demo
面试讲原理

真实项目基本不用

二、方式 ②：实现 Runnable

1.核心思想（非常重要）

线程（Thread） ≠ 任务（Runnable）

Runnable：你要做什么
Thread：谁来执行

解耦思想（面试高频）

2.标准写法（必须背）

java 复制代码

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行：" + Thread.currentThread().getName());
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable task = new MyRunnable();
        Thread t = new Thread(task);
        t.start();
    }
}

3.为什么它比继承 Thread 好？

可以继承别的类

多个线程共享同一个任务

符合面向对象设计

4.一个非常关键的共享例子（一定要看）

java 复制代码

class TicketTask implements Runnable {
    private int ticket = 100;

    public void run() {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName()
                + " 卖出第 " + ticket-- + " 张票");
        }
    }
}

public static void main(String[] args) {
    TicketTask task = new TicketTask();
    new Thread(task, "窗口1").start();
    new Thread(task, "窗口2").start();
}

同一个 task，被多个线程执行

5.什么时候用？

99% 的普通多线程场景

三、方式 ③：Callable + Future（能返回结果）

1.为什么需要它？

前两种：

不能返回结果
不能抛受检异常

Callable = 带返回值的 Runnable

2.代码（结构一定要搞懂）

java 复制代码

import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(1000);
        return 100;
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        Callable<Integer> task = new MyCallable();

        FutureTask<Integer> futureTask = new FutureTask<>(task);

        Thread t = new Thread(futureTask);
        t.start();

        Integer result = futureTask.get(); // 阻塞等待结果
        System.out.println("结果：" + result);
    }
}

3.关键角色理解（一定要清楚）

|-----------------|------------|
| 类 | 作用 |
| Callable<V> | 定义任务（有返回值） |
| FutureTask<V> | 任务 + 结果容器 |
| get() | 等待线程执行完成 |

4.什么时候用？

异步计算
并行任务
需要返回结果

四、方式 ④：线程池

1.为什么一定要用线程池？

直接 new Thread 的问题：

线程创建/销毁开销大
不可控
容易 OOM

线程池：

线程复用
统一管理
性能 & 稳定性最好

2.最基础用法（你先会这个）

java 复制代码

ExecutorService pool = Executors.newFixedThreadPool(3);

pool.execute(() -> {
    System.out.println(Thread.currentThread().getName());
});

pool.shutdown();

3.提交 Runnable / Callable

java 复制代码

// Runnable
pool.execute(() -> System.out.println("无返回值"));

// Callable
Future<Integer> f = pool.submit(() -> 1 + 2);
System.out.println(f.get());

4.真实项目用什么？

线程池 + Runnable / Callable

五、四种方式终极对比（背这个就够）

|-----------|-----|------|-------|
| 方式 | 返回值 | 继承限制 | 推荐指数 |
| 继承 Thread | ❌ | ❌ | ⭐ |
| Runnable | ❌ | ✅ | ⭐⭐⭐⭐ |
| Callable | ✅ | ✅ | ⭐⭐⭐⭐ |
| 线程池 | ✅ | ✅ | ⭐⭐⭐⭐⭐ |

六、面试一句话总结（直接抄）

Java 创建线程有四种方式：继承 Thread、实现 Runnable、实现 Callable 结合 Future、以及使用线程池。

实际开发中推荐使用线程池 + Runnable/Callable，避免直接创建线程。

七、给你 3 道自测题（你能答出来就是真的会了）

❓1

run() 和 start() 有什么区别？

❓2

为什么不推荐继承 Thread？

❓3

线程池解决了什么问题？