Java 创建线程的四种核心方式与最佳实践

Oliver

发布时间：2026-10-15| 4人浏览过

原创

在 Java 并发编程中，线程是执行任务的基本单元。文章深入分析了继承 Thread 类、实现 Runnable 接口、结合 FutureTask 与 Callable 获取返回值，以及利用 Lambda 表达式简化代码的四种核心创建方式，帮助开发者掌握不同场景下的最佳实践。

继承 Thread 类创建线程

最直接的方式是继承 java.lang.Thread 类并重写 run() 方法。这种方式将线程对象与任务逻辑耦合在一起，适用于简单的独立任务场景。

第1步：定义并启动线程

目的：创建一个独立的线程对象并执行特定任务。

入口/动作：新建类继承 Thread，重写 run 方法定义逻辑；在主线程中实例化该线程，调用 start() 而非 run 以触发并发执行。

重要参数：

线程名称：通过 setName 设置，便于日志追踪和调试。
启动方法：必须调用 start()，否则仅作为普通方法串行执行，不创建新线程。

@Slf4j(topic = "c.Test1")
public class Test1 {
    public static void main(String[] args) {
        // 1. 创建线程对象，使用匿名内部类重写 run 方法
        Thread t = new Thread() {
            @Override
            public void run() {
                log.debug("running"); // 子线程执行任务
            }
        };
        
        // 2. 设置线程名字，便于监控
        t.setName("t1");
        
        // 3. 启动线程
        t.start();
        
        // 主线程继续执行，两者并行
        log.debug("main thread running");
    }
}
/*
输出示例：
19:44:31.998 [main] DEBUG c.Test1 - main thread running
19:44:31.998 [t1]   DEBUG c.Test1 - running
*/

实现 Runnable 接口创建线程

相较于继承 Thread，实现 java.lang.Runnable 接口是更推荐的做法。它将“线程对象”与“任务逻辑”分离，符合面向对象设计中的单一职责原则，避免了 Java 单继承的限制。

第2步：解耦任务与线程

目的：将任务逻辑封装为 Runnable 对象，传递给 Thread 构造器。

入口/动作：新建类实现 Runnable 接口，重写 run 方法；实例化 Thread 时传入 Runnable 实例及线程名；调用 start() 启动。

@Slf4j(topic = "c.Test2")
public class Test2 {
    public static void main(String[] args) {
        // 1. 定义任务对象
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                log.debug("running");
            }
        };
        
        // 2. 将任务交给线程处理，同时指定线程名
        Thread t = new Thread(runnable, "t2");
        
        // 3. 启动线程
        t.start();
    }
}

第3步：利用 Lambda 简化代码

Runnable 接口是函数式接口（只有一个抽象方法），因此可以使用 Lambda 表达式大幅精简代码，提升可读性。

@Slf4j(topic = "c.Test3")
public class Test3 {
    public static void main(String[] args) {
        // 使用 Lambda 表达式直接定义任务逻辑
        Thread t = new Thread(() -> {
            log.debug("running");
        }, "t3");
        
        t.start();
    }
}

FutureTask 配合 Callable 获取返回值

当线程执行结束后需要返回结果或抛出checked异常时，Runnable 无法胜任。此时应使用 java.util.concurrent.Callable 接口配合 FutureTask。Callable 允许定义泛型返回值类型并声明抛出异常。

第4步：创建带返回值的任务

目的：执行耗时操作并同步获取计算结果。

入口/动作：

创建 FutureTask<T> 实例，传入 Callable 实现（支持 Lambda）。
将 FutureTask 作为任务传给 Thread 构造器。
调用 thread.start() 异步启动，或通过 futureTask.run() 同步执行。
调用 futureTask.get() 阻塞等待结果，该方法会抛出受检异常 ExecutionException 和 InterruptedException。

@Slf4j(topic = "c.Test4")
public class Test4 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. 定义 Callable 任务，返回 Integer 类型结果
        FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running...");
                Thread.sleep(1000); // 模拟耗时操作
                return 100;         // 返回结果
            }
        });
        
        // Lambda 简写版:
        // FutureTask<Integer> task = new FutureTask<>(() -> {
        //     log.debug("running...");
        //     Thread.sleep(1000);
        //     return 100;
        // });
        
        // 2. 创建线程，传递任务
        Thread t = new Thread(task, "t4");
        t.start();
        
        // 3. 主线程等待结果，此处会产生阻塞直到任务完成
        Integer result = task.get();
        log.debug("结果是:{}", result);
    }
}