Java多线程的实现方法主要有以下几种，每种方法都有其适用场景和特点：

1. 继承 Thread 类

通过继承 Thread 类并重写 run() 方法来实现多线程。

java

复制

class MyThread extends Thread {

@Override

public void run() {

System.out.println("Thread running by extending Thread");

}

}

// 使用

MyThread thread = new MyThread();

thread.start();

• 特点：
• 简单直接，但Java是单继承，继承 Thread 后无法继承其他类。
• 线程与任务绑定，复用性较差。

2. 实现 Runnable 接口

通过实现 Runnable 接口的 run() 方法，将任务逻辑与线程分离。

java

class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println("Thread running by implementing Runnable");

}

}

// 使用

Thread thread = new Thread(new MyRunnable());

thread.start();

• 特点：
• 解耦线程和任务，支持多线程共享同一任务实例。
• 推荐使用，避免单继承限制，更灵活。

3. 实现 Callable 接口

通过 Callable 接口实现有返回值的线程任务，配合 FutureTask 获取结果。

java

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

class MyCallable implements Callable {

@Override

public String call() throws Exception {

return "Result from Callable";

}

}

// 使用

FutureTask futureTask = new FutureTask<>(new MyCallable());

Thread thread = new Thread(futureTask);

thread.start();

String result = futureTask.get(); // 阻塞获取结果

• 特点：
• 支持返回值（通过 FutureTask.get()）和异常抛出。
• 通常与线程池结合使用（见下文）。

4. 使用线程池（Executor 框架）

通过 ExecutorService 线程池管理线程，避免频繁创建销毁线程的开销。

java

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

ExecutorService executor = Executors.newFixedThreadPool(4);

// 执行 Runnable 任务

executor.execute(() -> {

System.out.println("Task via Runnable in thread pool");

});

// 提交 Callable 任务

Future future = executor.submit(() -> "Result via Callable in pool");

String result = future.get();

executor.shutdown(); // 关闭线程池

• 特点：
• 高效管理线程生命周期，提升性能。
• 支持 Runnable 和 Callable 任务。
• 线程池类型丰富（如 newCachedThreadPool、newScheduledThreadPool）。

5. 基于 Fork/Join 框架

针对分治任务（Divide-and-Conquer）的并行框架，适合递归分解的大任务。

java

import java.util.concurrent.RecursiveTask;

import java.util.concurrent.ForkJoinPool;

class SumTask extends RecursiveTask {

// 实现递归拆分和合并逻辑

@Override

protected Integer compute() { /* ... */ }

}

// 使用

ForkJoinPool pool = new ForkJoinPool();

SumTask task = new SumTask(data);

Integer result = pool.invoke(task);

• 特点：
• 自动利用多核并行处理，适用于大数据计算。
• 基于工作窃取（Work-Stealing）算法优化负载均衡。

其他方式

• Lambda 表达式简化（本质是 Runnable）：

java

复制

new Thread(() -> System.out.println("Lambda简化")).start();

• 定时任务（Timer 和 TimerTask）：
  适用于周期性任务，但已逐渐被 ScheduledExecutorService 替代。

对比与总结

推荐实践：

• 优先选择 实现 Runnable 或 Callable，结合 线程池 管理资源。
• 需要返回值时使用 Callable + Future。
• 大数据并行计算考虑 Fork/Join 框架。