多线程编程是Java中一个重要的技术点，它允许程序并行执行多个任务，从而提高程序的执行效率。本文将详细介绍在Java中创建多线程的三种主要方法：继承Thread类、实现Runnable接口以及使用Callable和Future接口。

1. 继承 Thread 类

继承Thread类是创建线程的最直接方式。通过创建一个继承自Thread类的类，并重写run()方法，可以将线程执行的任务放入其中。

步骤：

1. 创建一个类继承java.lang.Thread类。
2. 重写run()方法，将线程执行的任务放入run()方法中。
3. 创建该类的实例。
4. 调用实例的start()方法启动线程。

示例代码：

class MyThread extends Thread {@Overridepublic void run() {// 线程执行的任务for (int i = 0; i < 5; i++) {System.out.println("Thread running: " + i);try {Thread.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Main {public static void main(String[] args) {MyThread thread = new MyThread();thread.start(); // 启动线程}
}

优点：

• 简单直接，代码清晰。
• 适用于不需要共享资源的场景。

缺点：

• 由于Java不支持多继承，如果继承了Thread类，就不能继承其他类。
• 不适用于需要共享资源的场景，因为每个线程都是独立的Thread实例。

2. 实现 Runnable 接口

实现Runnable接口是另一种创建线程的方法，它避免了Java单继承的限制。通过实现Runnable接口的类，并实现其run()方法，可以将线程执行的任务放入其中。

步骤：

1. 创建一个类实现java.lang.Runnable接口。
2. 实现run()方法，将线程执行的任务放入run()方法中。
3. 创建Runnable实现类的实例。
4. 创建Thread类的实例，并将Runnable实例传递给Thread构造函数。
5. 调用Thread实例的start()方法启动线程。

示例代码：

class MyRunnable implements Runnable {@Overridepublic void run() {// 线程执行的任务for (int i = 0; i < 5; i++) {System.out.println("Runnable running: " + i);try {Thread.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Main {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable);thread.start(); // 启动线程}
}

优点：

• 可以实现资源共享，适用于多个线程访问同一个资源的场景。
• 灵活性更高，因为可以通过实现接口来继承其他类。

缺点：

• 需要额外创建一个Thread实例，代码相对稍微复杂。

3. 使用 Callable 和 Future

如果需要在线程执行任务后获取结果，可以使用Callable接口。与Runnable不同，Callable的call()方法可以返回结果，并且可以抛出异常。通过FutureTask类可以包装Callable对象，并将其传递给Thread对象启动线程。

步骤：

1. 创建一个类实现java.util.concurrent.Callable接口。
2. 实现call()方法，将线程执行的任务和返回结果放入call()方法中。
3. 创建Callable实现类的实例。
4. 创建FutureTask实例，并将Callable实例传递给FutureTask构造函数。
5. 创建Thread类的实例，并将FutureTask实例传递给Thread构造函数。
6. 调用Thread实例的start()方法启动线程。
7. 调用FutureTask实例的get()方法获取线程执行结果。

示例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;class MyCallable implements Callable<Integer> {@Overridepublic Integer call() {// 线程执行的任务int sum = 0;for (int i = 0; i < 5; i++) {sum += i;System.out.println("Callable running: " + i);try {Thread.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {e.printStackTrace();}}return sum; // 返回计算结果}
}public class Main {public static void main(String[] args) {MyCallable myCallable = new MyCallable();FutureTask<Integer> futureTask = new FutureTask<>(myCallable);Thread thread = new Thread(futureTask);thread.start(); // 启动线程try {// 获取线程执行结果Integer result = futureTask.get();System.out.println("Result: " + result);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

优点：

• 可以在线程任务完成后获取返回结果。
• 可以抛出异常并进行处理。

缺点：

• 相对来说比Runnable接口实现稍微复杂一些。
• 需要额外的FutureTask来包装Callable实例。

总结

在Java中创建多线程的方法各有优缺点，选择哪种方法取决于具体的使用场景和需求。继承Thread类适用于简单的线程任务实现，而实现Runnable接口则更灵活，适用于需要共享资源的场景。使用Callable和Future接口不仅可以获取线程执行结果，还可以处理任务执行中的异常，更适合复杂的线程任务管理。