1. 继承 Thread 类
优点：
- 简单直观，适合初学者。
- 直接继承
Thread 类，可以方便地访问和使用 Thread 类的方法。
缺点：
- Java 不支持多继承，因此如果你的类已经继承了其他类，则不能继承
Thread 类。 - 仅适用于简单的线程任务。
示例：
class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread is running");
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}2. 实现 Runnable 接口
优点：
- 解决了单继承的问题，可以同时实现多个接口。
- 更灵活，可以将
Runnable 对象传递给多个线程。
缺点：
- 需要通过
Thread 类的构造器来创建线程对象。
示例：
class MyRunnable implements Runnable {
@Override
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 接口和 FutureTask
优点：
-
Callable 接口的 call() 方法可以返回值和抛出异常，更加灵活。 - 通过
FutureTask 可以获取任务的执行结果。
缺点：
- 相对复杂，适合需要返回结果的任务。
示例：
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
return 42;
}
public static void main(String[] args) throws Exception {
FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();
System.out.println("Result: " + futureTask.get());
}
}4. 使用 Executor 框架
优点：
- 提供了更高级的线程管理和调度功能。
- 适合大规模并发任务的管理。
- 代码更简洁，可维护性更高。
缺点：
- 学习曲线较陡峭，需要了解
Executor 框架的各个组件。
示例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable is running in Executor");
}
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
executor.submit(new MyRunnable());
}
executor.shutdown();
}
}
总结
- 继承
Thread 类：简单直观，适合初学者。 - 实现
Runnable 接口：灵活，解决单继承问题。 - 实现
Callable 接口和 FutureTask：适合需要返回结果的任务。 - 使用
Executor 框架：适合大规模并发任务的管理，提供高级功能。
推荐使用 Executor 框架，因为它提供了更强大的功能和更好的性能。