在 Java 中，创建线程有多种方式，以下是最常见的四种：
1. **通过继承 `Thread` 类**
2. **通过实现 `Runnable` 接口**
3. **通过实现 `Callable` 接口**
4. **通过使用 `Executor` 框架**
每种方式都有其特点和适用场景，下面将详细介绍每一种方式，并给出相应的简单例子。
1. 通过继承 `Thread` 类
这是创建线程的原始方式，通过继承 `Thread` 类并重写 `run()` 方法来定义线程的执行行为。
public class MyThread extends Thread {
public void run() {
System.out.println("Thread is running");
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start(); // 启动线程
}
}
2. 通过实现 `Runnable` 接口
实现 `Runnable` 接口是更推荐的方式，因为 Java 只允许单继承，通过实现接口可以避免因为继承 `Thread` 类而导致的类继承层次混乱。
public class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable is running");
}
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start(); // 启动线程
}
}
3. 通过实现 `Callable` 接口
`Callable` 接口与 `Runnable` 类似，但它允许线程返回结果或抛出异常。这意味着 `Callable` 任务可以用于实现有返回结果的异步计算。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable implements Callable<Integer> {
public Integer call() {
return 1;
}
public static void main(String[] args) {
FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();
try {
Integer result = futureTask.get(); // 获取异步计算的结果
System.out.println("Result is: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
4. 通过使用 `Executor` 框架
`Executor` 框架是 Java 并发编程中的一个高级工具，它允许你管理和控制线程池。通过使用 `Executor`，你可以更好地控制线程的生命周期，并且可以复用线程，从而提高性能。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyExecutor {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建一个包含 5 个线程的线程池
executorService.execute(new MyRunnable()); // 提交一个 Runnable 任务
executorService.execute(() -> System.out.println("Executor task is running")); // 提交一个 Lambda 表达式任务
executorService.shutdown(); // 关闭线程池
}
}
总结
在 Java 中，创建线程有多种方式，每种方式都有其特点和适用场景。通过继承 `Thread` 类是最基础的方式，但可能会导致类层次结构混乱。实现 `Runnable` 接口是更推荐的方式，因为它允许线程重用，避免了单继承的限制。`Callable` 接口允许线程有返回结果或抛出异常，适用于有结果要求的异步计算。`Executor` 框架提供了更高级的线程管理功能，允许你创建和管理线程池，从而提高性能和资源利用率。
