前言
在Java开发中，
线程
是并发编程中的核心工具。
无论是为了提高程序运行效率，还是为了处理复杂的并发任务，我们都需要在代码中使用线程。
但如果你只知道
Thread
和
Runnable
两种方式，那可就有点落后了。
其实，Java 提供了多种方式来创建线程，每一种都有其独特的优势和适用场景。
这篇文章将从浅入深，详细剖析
Java 创建线程的8种方法
，每种方法都会附带示例代码和场景解析，帮你彻底掌握线程的创建与管理，希望对你会有所帮助。
(我最近开源了一个基于 SpringBoot+Vue+uniapp 的商城项目，欢迎访问和star。)[
https://gitee.com/dvsusan/susan_mall
]
1. 继承 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
后就不能再继承其他类。
优缺点
- 优点：
简单直观，适合小型任务。
- 缺点：
限制了类的继承，无法复用已有的逻辑。
2. 实现 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
对象。
3. 实现 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
略高。
4. 使用线程池
线程池是一种高效的线程管理机制，可以复用线程，减少创建和销毁线程的开销。
示例代码
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 服务的请求处理。
优缺点
- 优点：
高效管理线程生命周期，避免频繁创建和销毁线程。
- 缺点：
需要合理配置线程池参数，否则可能导致资源浪费。
5. 使用 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();
}
}
场景解析
适用于周期性任务，比如定时备份、定时清理缓存等。
优缺点
- 优点：
易于实现定时和周期性任务。
- 缺点：
不适合复杂调度场景。
6. 使用 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 密集型任务。
7. 使用 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);
}
}
场景解析
适用于异步任务链式调用，比如远程服务调用。
优缺点
- 优点：
功能强大，代码简洁。
- 缺点：
学习成本较高。
8. 使用 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等等。
通过这些方法的组合，可以让你的代码更加高效、优雅！
最后说一句(求关注，别白嫖我)
如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下我的同名公众号：苏三说技术，您的支持是我坚持写作最大的动力。
求一键三连：点赞、转发、在看。
关注公众号：【苏三说技术】，在公众号中回复：进大厂，可以免费获取我最近整理的10万字的面试宝典，好多小伙伴靠这个宝典拿到了多家大厂的offer。