创建线程有哪几种方式？-Java面试题-PHP中文网

创建线程主要有三种方式：继承Thread类、实现Runnable接口、使用Callable与ExecutorService线程池。继承Thread类简单但受限于单继承，不利于扩展；实现Runnable接口更灵活，实现任务与线程分离，推荐使用；Callable配合ExecutorService可获取返回值和异常处理，结合线程池提升系统性能与稳定性，适用于高并发场景。线程池通过复用线程降低开销，提高响应速度和资源管理能力，是现代Java并发编程的首选方案。

创建线程有哪几种方式？

创建线程，这在多线程编程里是个基础又核心的话题。说到底，在Java里（因为这是我们日常接触最多的），主要有那么几种途径来让你的代码跑在独立的执行流上：最直接的两种是继承 Thread 类和实现 Runnable 接口，而更现代、更推荐的方式，则是结合 Callable 接口与 ExecutorService 线程池来管理和执行任务。每种方式都有它的适用场景和一些需要考量的地方。

解决方案

要让程序中的某个任务独立于主线程运行，我们通常会采取以下几种方式，它们各有优劣，也反映了Java并发编程的发展历程。

1. 继承 Thread 类

这是最直观的一种方式，直接创建一个 Thread 的子类，然后重写它的 run() 方法。这个 run() 方法就是线程要执行的任务逻辑。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " - 我是继承Thread类创建的线程，正在执行任务...");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断状态
            System.err.println(Thread.currentThread().getName() + " 被中断了。");
        }
        System.out.println(Thread.currentThread().getName() + " - 任务执行完毕。");
    }
}

// 使用方式
public class ThreadCreationDemo {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.setName("Thread-Inherit");
        thread1.start(); // 启动线程，执行run方法
    }
}

登录后复制

这种方式简单明了，但有个明显的限制：Java是单继承的，一旦你继承了 Thread 类，你的任务类就不能再继承其他类了。这在实际项目中经常是个问题。

2. 实现 Runnable 接口

这是更常用、也更推荐的方式，因为它避免了单继承的限制。你创建一个类去实现 Runnable 接口，然后实现 run() 方法。接着，把这个 Runnable 实例作为参数传给 Thread 类的构造器，再启动 Thread 对象。

class MyRunnable implements Runnable {
    private String taskName;

    public MyRunnable(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " - " + taskName + "：我是实现Runnable接口创建的线程，正在执行任务...");
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(Thread.currentThread().getName() + " - " + taskName + " 被中断了。");
        }
        System.out.println(Thread.currentThread().getName() + " - " + taskName + "：任务执行完毕。");
    }
}

// 使用方式
public class RunnableCreationDemo {
    public static void main(String[] args) {
        MyRunnable runnableTask = new MyRunnable("RunnableTask-1");
        Thread thread2 = new Thread(runnableTask);
        thread2.setName("Thread-Runnable");
        thread2.start();

        // 也可以使用匿名内部类或Lambda表达式
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " - 匿名Runnable任务执行...");
        }, "Thread-Lambda").start();
    }
}

登录后复制

这种方式将任务的定义与线程的创建分离，使得代码结构更清晰，也更灵活。

3. 实现 Callable 接口配合 ExecutorService 线程池

这是现代Java并发编程中推荐的、更高级的线程创建和管理方式。Callable 接口与 Runnable 类似，但它的 call() 方法可以有返回值，并且可以抛出受检查异常。通常，Callable 任务不会直接传给 Thread 构造器，而是提交给 ExecutorService 线程池来执行。线程池会返回一个 Future 对象，你可以通过它来获取任务的执行结果或检查任务状态。

清程爱画

AI图像与视频生成平台，拥有超丰富的工作流社区和多种图像生成模式。

170

查看详情

import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    private String taskName;

    public MyCallable(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " - " + taskName + "：我是Callable任务，正在执行...");
        long duration = (long) (Math.random() * 200);
        Thread.sleep(duration); // 模拟耗时操作
        if (duration < 50) {
            throw new RuntimeException(taskName + " - 故意抛出异常，耗时太短！");
        }
        System.out.println(Thread.currentThread().getName() + " - " + taskName + "：任务执行完毕，耗时 " + duration + "ms。");
        return taskName + " 执行成功，结果是：" + duration;
    }
}

// 使用方式
public class CallableExecutorDemo {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交Callable任务
        Future<String> future1 = executor.submit(new MyCallable("CallableTask-1"));
        Future<String> future2 = executor.submit(new MyCallable("CallableTask-2"));
        Future<String> future3 = executor.submit(new MyCallable("CallableTask-3")); // 可能会排队

        try {
            // 获取任务结果，get()方法会阻塞直到任务完成
            System.out.println("Future 1 结果: " + future1.get());
            System.out.println("Future 2 结果: " + future2.get());
            System.out.println("Future 3 结果: " + future3.get());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("主线程被中断。");
        } catch (ExecutionException e) {
            // 捕获任务执行中抛出的异常
            System.err.println("任务执行异常: " + e.getCause().getMessage());
        } finally {
            // 关闭线程池
            executor.shutdown();
            System.out.println("线程池已关闭。");
        }
    }
}

登录后复制

这种方式是实际生产环境中处理并发任务的基石。它不仅能返回结果、处理异常，更重要的是，它引入了线程池的概念，极大地提升了线程管理的效率和系统的稳定性。

为什么说实现 `Runnable` 接口比继承 `Thread` 类更好？

这个问题其实在实际开发中经常被提起，我个人是强烈推荐 Runnable 接口的。最核心的原因，就像前面提到的，是Java的单继承机制。如果你继承了 Thread 类，那么你的任务类就不能再继承其他任何类了。这在复杂的业务逻辑中，几乎是不可接受的。想象一下，你的业务类可能需要继承一个基础的Service类，或者一个抽象的BaseDao类，这时候如果它同时还要作为线程任务，那 Thread 继承方式就直接堵死了。

而 Runnable 接口则完全没有这个问题。它仅仅定义了一个 run() 方法，你的任务类可以自由地继承其他类，同时实现 Runnable 接口。这体现了“面向接口编程”的理念，把“任务”本身和“线程”这个执行机制分离开来。一个 Runnable 对象可以被多个 Thread 对象共享（虽然这需要谨慎处理共享状态），或者同一个任务逻辑可以被不同的线程实例执行。这种解耦带来的灵活性和扩展性，是继承 Thread 所无法比拟的。简单来说，它让你的代码更干净，更符合软件设计的原则。

什么时候应该使用 `Callable` 和 `Future`？

当我们不仅仅是想让一个任务在后台跑起来，还关心它跑完之后的结果，或者想知道它有没有出什么岔子时，Callable 和 Future 的组合就显得尤为重要了。Runnable 的 run() 方法是 void 类型的，它不能直接返回结果，也不能直接抛出受检查异常。这意味着如果你需要任务的执行结果，或者需要对任务执行中的异常进行精细化处理，Runnable 就显得力不从心了，你可能需要自己设计一套回调机制或者共享变量来传递结果和异常，这会增加代码的复杂性。

Callable 的 call() 方法则完美解决了这些痛点。它可以返回一个泛型结果，而且可以抛出任何 Exception。配合 ExecutorService 提交任务后得到的 Future 对象，你可以在主线程中非阻塞地等待任务完成，或者在任务完成后通过 future.get() 获取结果。如果任务执行过程中抛出了异常，这个异常会被 Future 捕获，并在你调用 get() 方法时以 ExecutionException 的形式重新抛出，这样你就能统一处理任务执行中的错误。

举个例子，如果你在做一个异步的数据处理流程，比如从多个远程服务并行获取数据，然后汇总分析。每个获取数据的任务都可以是一个 Callable，它们返回获取到的数据。你把这些 Callable 提交给线程池，得到一堆 Future，然后等待所有 Future 都完成，再从每个 Future 中取出数据进行汇总。这种模式非常清晰高效，而且对于任务的超时、取消等操作，Future 也提供了相应的方法。

线程池在实际开发中的重要性体现在哪里？

在实际的软件开发，特别是高并发服务中，线程池的重要性几乎是不可替代的。我记得刚开始写多线程代码的时候，总是习惯性地 new Thread().start()，结果在系统负载一高，并发量一上来的时候，服务就直接卡死甚至宕机。后来才明白，这都是因为线程创建和销毁的开销太大了，而且无限制地创建线程还会迅速耗尽系统资源，比如内存。

线程池就像一个“线程的管家”，它预先创建了一定数量的线程，形成一个“池子”。当有任务需要执行时，直接从池子里取一个空闲线程来执行任务，任务执行完毕后，线程不会被销毁，而是回到池子里等待下一个任务。这样做的优势非常明显：

降低资源消耗： 最直接的好处就是避免了频繁创建和销毁线程的开销。线程的创建和销毁是比较耗时的操作，尤其是当任务量非常大时，这种开销会变得非常显著。
提高响应速度： 任务提交后，如果池子里有空闲线程，任务可以立即执行，无需等待线程创建，从而提高了系统的响应速度。
提高线程的可管理性： 线程池统一管理所有线程，包括线程的分配、调度、监控等。我们可以通过配置线程池的参数（如核心线程数、最大线程数、队列容量等）来控制并发量，避免系统因线程过多而崩溃。这就像是给系统戴上了“安全帽”，限制了并发的上限，让系统运行更稳定。
提供更多功能： ExecutorService 不仅仅是管理线程，它还提供了很多高级功能，比如定时任务调度 (ScheduledExecutorService)、任务的提交与结果获取 (submit 方法返回 Future)，以及对线程生命周期的精细控制等。