创建线程的 8 种方法 - 文章 - 开发者社区

大家好，我是苏三，又跟大家见面了。

前言

在Java开发中，线程是并发编程中的核心工具。

无论是为了提高程序运行效率，还是为了处理复杂的并发任务，我们都需要在代码中使用线程。

但如果你只知道 Thread 和 Runnable 两种方式，那可就有点落后了。

其实，Java 提供了多种方式来创建线程，每一种都有其独特的优势和适用场景。

这篇文章将从浅入深，详细剖析 Java 创建线程的8种方法 ，希望对你会有所帮助。

继承 Thread 类

直接继承 Thread 类，重写 run() 方法，将任务逻辑写在 run() 中。

通过调用 start() 方法启动线程。

示例代码


        
          
class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println("线程名称：" + Thread.currentThread().getName() + " 正在执行任务");  
    }  
}  
  
public class ThreadExample {  
    public static void main(String[] args) {  
        MyThread thread1 = new MyThread();  
        MyThread thread2 = new MyThread();  
        thread1.start(); // 启动线程  
        thread2.start();  
    }  
}

场景解析

继承 Thread 是最简单的方式，非常适合初学者学习线程的基本原理。

但这种方式扩展性差，因为 Java 是单继承语言，继承了 Thread 后就不能再继承其他类。

优缺点

优点： 简单直观，适合小型任务。
缺点： 限制了类的继承，无法复用已有的逻辑。

实现 Runnable 接口

实现 Runnable 接口，将任务逻辑写在 run() 方法中。

通过 Thread 构造方法将 Runnable 对象传入，启动线程。

示例代码


        
          
class MyRunnable implements Runnable {  
    @Override  
    public void run() {  
        System.out.println("线程名称：" + Thread.currentThread().getName() + " 正在执行任务");  
    }  
}  
  
public class RunnableExample {  
    public static void main(String[] args) {  
        Thread thread1 = new Thread(new MyRunnable());  
        Thread thread2 = new Thread(new MyRunnable());  
        thread1.start();  
        thread2.start();  
    }  
}

场景解析

相比继承 Thread，实现 Runnable 接口更灵活，避免了单继承的限制。大多数开发场景中，更推荐使用这种方式。

优缺点

优点： 解耦任务逻辑和线程对象，灵活性更高。
缺点： 需要额外创建 Thread 对象。

实现 Callable 接口

Callable 接口是 Java 5 引入的，类似于 Runnable，但它支持返回值，并可以抛出异常。

示例代码


        
          
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
  
class MyCallable implements Callable<String> {  
    @Override  
    public String call() throws Exception {  
        return "线程名称：" + Thread.currentThread().getName() + "，任务执行完成";  
    }  
}  
  
public class CallableExample {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());  
        Thread thread = new Thread(futureTask);  
        thread.start();  
  
        // 获取线程返回结果  
        System.out.println("线程返回结果：" + futureTask.get());  
    }  
}

场景解析

如果你的线程需要返回结果，Callable 是更好的选择，比如数据查询、复杂计算等场景。

优缺点

优点： 支持返回值和异常处理，功能更强大。
缺点： 代码复杂度比 Runnable 略高。

使用线程池

线程池是一种高效的线程管理机制，可以复用线程，减少创建和销毁线程的开销。

示例代码


        
          
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class ThreadPoolExample {  
    public static void main(String[] args) {  
        ExecutorService executorService = Executors.newFixedThreadPool(3);  
  
        Runnable task = () -> System.out.println("线程名称：" + Thread.currentThread().getName() + " 正在执行任务");  
  
        for (int i = 0; i < 5; i++) {  
            executorService.execute(task);  
        }  
  
        executorService.shutdown();  
    }  
}

场景解析

适用于需要高并发处理任务的场景，比如 Web 服务的请求处理。

优缺点

优点： 高效管理线程生命周期，避免频繁创建和销毁线程。
缺点： 需要合理配置线程池参数，否则可能导致资源浪费。

使用 ScheduledExecutorService

ScheduledExecutorService 是 Java 提供的一种定时任务调度机制，可以在指定时间点或周期性地执行任务。

示例代码


        
          
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
  
public class ScheduledExample {  
    public static void main(String[] args) {  
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);  
  
        Runnable task = () -> System.out.println("当前时间：" + System.currentTimeMillis());  
  
        // 延迟1秒后，每2秒执行一次  
        scheduler.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);  
  
        // 程序运行一段时间后需要手动关闭线程池  
        // scheduler.shutdown();  
    }  
}

场景解析

适用于周期性任务，比如定时备份、定时清理缓存等。

优缺点

优点： 易于实现定时和周期性任务。
缺点： 不适合复杂调度场景。

使用 Fork/Join 框架

Fork/Join 是 Java 7 引入的一种并行计算框架，适合将大任务分解成多个子任务并行处理。

示例代码


        
          
import java.util.concurrent.RecursiveTask;  
import java.util.concurrent.ForkJoinPool;  
  
class SumTask extends RecursiveTask<Integer> {  
    private final int start, end;  
  
    public SumTask(int start, int end) {  
        this.start = start;  
        this.end = end;  
    }  
  
    @Override  
    protected Integer compute() {  
        if (end - start <= 10) {  
            int sum = 0;  
            for (int i = start; i <= end; i++) {  
                sum += i;  
            }  
            return sum;  
        } else {  
            int mid = (start + end) / 2;  
            SumTask leftTask = new SumTask(start, mid);  
            SumTask rightTask = new SumTask(mid + 1, end);  
            invokeAll(leftTask, rightTask);  
            return leftTask.join() + rightTask.join();  
        }  
    }  
}  
  
public class ForkJoinExample {  
    public static void main(String[] args) {  
        ForkJoinPool pool = new ForkJoinPool();  
        SumTask task = new SumTask(1, 100);  
        System.out.println("总和：" + pool.invoke(task));  
    }  
}

场景解析

适合大量数据的并行处理，比如递归计算。

优缺点

优点： 提高多核 CPU 的利用率。
缺点： 不适合 I/O 密集型任务。

使用 CompletableFuture

CompletableFuture 是 Java 8 提供的一种异步编程工具，支持链式调用，非常适合复杂任务的分解与组合。

示例代码


        
          
import java.util.concurrent.CompletableFuture;  
  
public class CompletableFutureExample {  
    public static void main(String[] args) {  
        CompletableFuture.supplyAsync(() -> {  
            System.out.println("任务执行：" + Thread.currentThread().getName());  
            return "任务结果";  
        }).thenApply(result -> {  
            System.out.println("处理结果：" + result);  
            return "最终结果";  
        }).thenAccept(System.out::println);  
    }  
}

场景解析

适用于异步任务链式调用，比如远程服务调用。

优缺点

优点： 功能强大，代码简洁。
缺点： 学习成本较高。

使用 Guava 的 ListenableFuture

Guava 提供了 ListenableFuture，对 Future 进行了增强，支持任务完成后的回调处理。


        
          
import com.google.common.util.concurrent.*;  
  
import java.util.concurrent.Executors;  
  
public class ListenableFutureExample {  
    public static void main(String[] args) {  
        ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2));  
  
        ListenableFuture<String> future = service.submit(() -> {  
            Thread.sleep(1000);  
            return "任务完成";  
        });  
  
        Futures.addCallback(future, new FutureCallback<String>() {  
            @Override  
            public void onSuccess(String result) {  
                System.out.println("任务成功，结果：" + result);  
            }  
  
            @Override  
            public void onFailure(Throwable t) {  
                System.out.println("任务失败：" + t.getMessage());  
            }  
        }, service);  
  
        service.shutdown();  
    }  
}

总结

以上就是 Java 中创建线程的 8 种方法，每一种方法都有其适用场景和优缺点。

下面给大家总结一下各自的优缺点：

方法	适用场景	优点	缺点
继承Thread类	简单任务	直观易懂	限制了类的继承
实现Runnable接口	大多数场景	灵活，不影响继承关系	无返回值
实现Callable接口	返回结果或抛异常的任务	支持返回值	需要配合 `FutureTask` 使用
线程池（ExecutorService）	高并发任务	高效管理线程	配置复杂
ScheduledExecutorService	周期性任务	易于实现定时调度	不适合复杂调度
Fork/Join框架	数据并行计算	提高多核利用率	不适合 I/O 密集型任务
CompletableFuture	异步任务链式调用	功能强大	学习曲线高
Guava的ListenableFuture	异步任务并带回调	回调机制强大，扩展性好	引入了第三方依赖

希望大家在实际开发中，能根据场景选择合适的方式。

比如：小任务用 Runnable，复杂计算用 Callable，高并发场景用线程池，而异步任务可以用 CompletableFuture 或 ListenableFuture等等。

通过这些方法的组合，可以让你的代码更加高效、优雅！

最后欢迎加入苏三的星球，你将获得：商城微服务系统、商城系统、秒杀系统、代码生成工具、苏三demo系统等项目实战。系统设计、性能优化、技术选型、高频面试题、底层原理、Spring源码解读、工作经验分享、痛点问题等多个优质专栏。

picture.image

还有1V1答疑、修改简历、职业规划、送书活动、技术交流。目前星球已经更新了 4500+ 篇优质内容，还在持续爆肝中.....

星球已经被官方推荐了3次，收到了小伙伴们的一致好评。戳我加入学习，已有1500+小伙伴加入学习。

picture.image