id="content_views">

一、前言

上一篇文章我们介绍了

Java

接口。

但在实际开发中，这两种方式并不能满足所有场景需求，比如需要获取线程执行结果、需要统一管理线程生命周期等。

本文将全面讲解

Java

中创建线程的5种方式，分析它们的优缺点和适用场景，并通过代码案例帮助大家掌握实际用法。

二、5

种线程创建方式

方式

方法启动线程。

实现步骤

1. 定义一个类继承 Thread 类；

2. 重写 run() 方法，编写线程执行逻辑；

3. 创建该类的实例对象，调用 start() 方法启动线程。

代码案例

class MyThread extends Thread {

  public MyThread(String

name) {

  public void run() {

  for (int i = 1;

<= 5;

System.out.println(Thread.currentThread().getName()

+ "

} catch (InterruptedException

public class ThreadExtendDemo {

  public static void main(String[]

args) {

  MyThread thread1 = new MyThread("线程A");

  MyThread thread2 = new MyThread("线程B");

优缺点分析

• 优点：实现简单，直接继承

  Thread

  就能获取当前线程对象。

• 缺点：

1. Java

   Thread

   类后无法再继承其他类，扩展性差。

2. run()

   方法没有返回值，无法获取线程执行结果。

3. 线程与任务耦合度高，一个线程类只能对应一个任务。

方式

2：实现

类的构造方法创建线程。

实现步骤

1. 定义一个类实现 Runnable 接口；

2. 实现

   run()方法，编写线程执行逻辑；

3. 创建

   Runnable

   实现类的实例，作为参数传入 Thread 构造方法；

4. 调用

   Thread

   start()方法启动线程。

代码案例

class MyRunnable implements Runnable {

  public void run() {

  for (int i = 1;

<= 5;

System.out.println(Thread.currentThread().getName()

+ "

} catch (InterruptedException

public class RunnableImplDemo {

  public static void main(String[]

args) {

  MyRunnable task = new MyRunnable();

  Thread thread1 = new Thread(task, "线程C");

  Thread thread2 = new Thread(task, "线程D");

优缺点分析

• 优点：

1. 避免了单继承的限制，实现

   Runnable

   接口的同时还能继承其他类。

2. 线程与任务解耦，一个任务对象可以被多个线程共享。

3. 适合多个线程执行相同任务的场景。

• 缺点： run()

  方法仍然没有返回值，无法获取线程执行结果；无法直接抛出受检异常。

方式

3：实现

FutureTask

在实际开发中，我们经常需要获取线程的执行结果（比如异步计算任务），

Callable

类来使用。

实现步骤

1. 定义一个类实现

   Callable<T>

   方法，编写带返回值的线程逻辑；

2. 创建

   Callable

   方法获取线程执行结果（会阻塞直到结果返回）。

代码案例

class="language-java">import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

/**

class MyCallable implements Callable

  private int start;

  private int end;

  public MyCallable(int start, int end) {

  public Integer call() throws Exception

  int sum = 0;

  for (int i = start;

<=

System.out.println(Thread.currentThread().getName()

+ "

public class CallableImplDemo {

  public static void main(String[]

args) throws Exception

= new MyCallable(1, 5);

= new MyCallable(6, 10);

创建FutureTask对象，包装Callable任务（FutureTask实现了RunnableFuture接口，可作为Thread的参数）

= new FutureTask<>(task1);

= new FutureTask<>(task2);

  new Thread(futureTask1, "计算线程1").start();

  new Thread(futureTask2, "计算线程2").start();

  Integer sum1 = futureTask1.get();

  Integer sum2 = futureTask2.get();

System.out.println("1-5的累加和：" +

sum1);

System.out.println("6-10的累加和：" +

sum2);

System.out.println("总和：" +

(sum1

}

核心说明

1. Callable 是一个泛型接口，

   call()

   方法获取任务执行结果。

2. get()

   get()

   的线程会等待，直到目标线程执行完毕返回结果。

优缺点分析

• 优点：

1. 支持获取线程执行结果，满足异步计算场景需求。

2. call()

   方法可以抛出受检异常，便于异常处理。

3. 同样避免了单继承的限制。

• 缺点：

1. 实现步骤相对复杂，需要配合

   FutureTask

   方法会阻塞主线程，若结果获取时机不当，会影响程序执行效率。

方式

4：使用线程池创建线程

前面三种方式都是直接创建线程对象，在高并发场景下，频繁创建和销毁线程会带来巨大的性能开销。

线程池可以复用线程，控制并发线程数量，降低系统资源消耗，是实际开发中最推荐的线程创建方式。

Java

工具类或

来创建线程池。

实现步骤

1. 通过

   Executors

   任务提交到线程池；

2. 线程池自动分配线程执行任务；

3. 任务执行完成后，关闭线程池（避免资源泄漏）。

代码案例

1：使用

class="language-java">import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

public class ThreadPoolDemo1 {

  public static void main(String[]

args) {

  ExecutorService threadPool = Executors.newFixedThreadPool(3);

  for (int i = 1;

<= 5;

  int taskId = i;

System.out.println(Thread.currentThread().getName()

+ "

} catch (InterruptedException

关闭线程池（核心：先shutdown()，再awaitTermination()确保任务执行完毕）

class="language-java">import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

public class ThreadPoolDemo2 {

  public static void main(String[]

args) {

  int corePoolSize = 2; //

核心线程数

  int maximumPoolSize = 4; //

最大线程数

  long keepAliveTime = 60; //

非核心线程空闲存活时间

  TimeUnit unit = TimeUnit.SECONDS; //

时间单位

= new ArrayBlockingQueue<>(2);

  ThreadPoolExecutor threadPool = new ThreadPoolExecutor(

  for (int i = 1;

<= 6;

  int taskId = i;

System.out.println(Thread.currentThread().getName()

+ "

} catch (InterruptedException

核心说明

1. 线程池的核心参数包括：核心线程数、最大线程数、空闲存活时间、任务队列、拒绝策略等。

2. Executors

   newFixedThreadPool

   自定义线程池，避免资源耗尽风险。

3. 线程池会复用线程执行任务，当任务数超过线程池处理能力时，任务会被放入队列等待。

优缺点分析

• 优点：

1. 线程复用，降低线程创建和销毁的性能开销。

2. 控制最大并发数，避免大量线程抢占资源导致系统瘫痪。

3. 提供任务队列、拒绝策略等功能，便于任务管理和异常处理。

4. 支持提交

   Runnable

   任务，灵活适配不同场景。

• 缺点：线程池参数配置需要根据业务场景调优，参数配置不当会影响性能。

方式

5：使用

引入的 CompletableFuture 是对 Future 的增强，不仅能创建异步任务，还支持任务编排（串行、并行、聚合），无需手动管理线程，底层默认使用 ForkJoinPool.commonPool() 线程池，也可自定义线程池。

实现步骤

1. 使用 CompletableFuture.supplyAsync()（有返回值）或 runAsync()（无返回值）创建异步任务；

2. （可选）传入自定义线程池，避免使用默认线程池；

3. 调用 join() 或 get() 获取结果（join() 不抛出检查异常，更友好）；

4. （可选）通过 ***nApply()、***nAccept() 等方法编排任务。

代码示例

示例

1：基础使用（无返回值

java.util.concurrent.CompletableFuture;

import

java.util.concurrent.ExecutorService;

import

java.util.concurrent.Executors;

public class CompletableFutureDemo {

  public static void main(String[] args) {

Thread.currentThread().getName()

+ "

} catch (InterruptedException

有返回值的异步任务（supplyAsync），使用自定义线程池

Executors.newFixedThreadPool(2);

CompletableFuture.supplyAsync(()

->

Thread.currentThread().getName()

+ "

} catch (InterruptedException

  return "异步任务执行完成";

System.out.println("有返回值任务结果：" +

result);

Thread.currentThread().getName()

+ "

System.out.println("编排任务结果：" +

***nFuture.join());

}

示例

java.util.concurrent.CompletableFuture;

public class CompletableFutureExceptionDemo {

  public static void main(String[] args) {

CompletableFuture.supplyAsync(()

->

System.out.println("任务执行异常：" +

ex.getMessage());

System.out.println("异常处理后结果：" +

future.join());

示例3：进阶使用（自定义线程池

链式调用）

java.util.concurrent.CompletableFuture;

import

java.util.concurrent.ExecutorService;

import

java.util.concurrent.Executors;

/**

public class CompletableFutureDemo2 {

  public static void main(String[] args) {

Executors.newFixedThreadPool(2);

CompletableFuture.supplyAsync(()

->

  for (int i

= 1;

System.out.println(Thread.currentThread().getName()

+ "

} catch (InterruptedException

System.out.println(Thread.currentThread().getName()

+ "

System.out.println("最终结果：" +

result);

}

核心说明

CompletableFuture

本身不创建线程，而是依赖线程池执行异步任务：

• 默认情况下，runAsync()/supplyAsync()

  会使用

  内置的通用线程池）执行任务；

• 也可通过重载方法（如

  Executor)）指定自定义线程池，避免全局线程池资源竞争。

优缺点分析

• 优点：

1. 无需手动管理线程和

   FutureTask，API

   ***nApply、***nCombine、whenComplete

   等链式调用，轻松实现多异步任务的串行、并行、聚合。

2. 提供

   exceptionally、handle

   等方法，可优雅处理异步任务中的异常，避免主线程阻塞崩溃。

3. 可指定任务执行的线程池，避免默认

   ForkJoinPool

   ***nAccept）异步处理结果，避免主线程阻塞。

缺点：

1. API

   丰富且抽象，新手需要理解异步回调、线程池适配等概念。

2. 异步链式调用的执行流程分散，调试时难以追踪完整调用链路。

3. ForkJoinPool.commonPool()

   是全局共享的，大量任务提交可能导致资源耗尽。

三、线程创建方式对比表

style="width:

89px">

是否支持继承其他类

style="width:

168px">

继承Thread类

style="width:

单继承限制

style="width:

168px">

实现Runnable接口

style="width:

157px">

Runnable

Thread

style="width:

支持

style="width:

168px">

实现Callable接口+FutureTask

style="width:

157px">

Callable

FutureTask

Thread

style="width:

支持

style="width:

157px">

ExecutorService

ThreadPoolExecutor

style="width:

支持

style="width:

CompletableFuture（Java8+）

style="width:

157px">

CompletableFuture

ExecutorService

style="width:

支持

适用场景
简单线程任务，不需要复用线程
多个线程执行相同任务，需要继承其他类
需要获取线程执行结果的异步计算场景
高并发场景，需要统一管理线程生命周期
现代异步编程，多任务组合、非阻塞结果处理

四、核心注意事项

1. 启动线程必须调用start()方法：直接调用

   run()

   方法会以普通方法的形式串行执行，不会启动新线程。

2. 线程池使用后必须关闭：若不关闭线程池，核心线程会一直存活，导致程序无法正常退出。

3. FutureTask的get()方法会阻塞：建议在所有线程提交后再调用

   get()

   设置超时时间，避免主线程长时间阻塞。

4. 生产环境慎用Executors工具类： Executors

   newCachedThreadPool

   自定义参数。

五、总结

本文详细讲解了

Java

CompletableFuture，每种方式都有其适用场景。

在实际开发中，线程池结合

CompletableFuture

是更优的推荐方案，而纯线程池也仍是核心优选，它们能有效提升程序性能和稳定性；其中

CompletableFuture

更能解决传统异步编程中回调嵌套的问题，进一步简化异步任务的编排与结果处理。

下一篇文章，我们将深入讲解

Java

线程的生命周期与状态转换，通过代码演示不同状态之间的转换路径，帮助大家理解线程状态的本质。