在 Java 中，创建线程的方式主要有两种：继承 Thread 类 和 实现 Runnable 接口。此外，还可以通过 线程池 来创建和管理线程。以下是这几种创建线程的方式：

1. 继承 Thread 类

• 原理：创建一个新类继承 Thread 类，并重写 run() 方法。通过调用 start() 方法启动线程，start() 方法会调用 run() 方法来执行线程的任务。

• 优点：实现简单，适合处理需要线程执行的任务。

• 缺点：Java 不支持多重继承，所以如果继承了 Thread 类，就不能再继承其他类。如果线程的任务和继承的类有其他逻辑时，这种方式不太适用。

• 示例：

复制
1class MyThread extends Thread {
2    @Override
3    public void run() {
4        System.out.println("Thread is running");
5    }
6}
7
8public class Main {
9    public static void main(String[] args) {
10        MyThread thread = new MyThread();
11        thread.start();  // 启动线程
12    }
13}

2. 实现 Runnable 接口

• 原理：创建一个类实现 Runnable 接口，并重写 run() 方法。然后将该类的实例传递给 Thread 对象并调用 start() 方法来启动线程。

• 优点：

  • 允许类继承其他类，因为 Runnable 接口是实现接口，不是继承类。
  • 可以共享同一个 Runnable 实现给多个线程使用。

• 缺点：创建线程时需要额外创建一个 Thread 对象，并将 Runnable 对象传入。

• 示例：

复制
1class MyRunnable implements Runnable {
2    @Override
3    public void run() {
4        System.out.println("Thread is running");
5    }
6}
7
8public class Main {
9    public static void main(String[] args) {
10        MyRunnable runnable = new MyRunnable();
11        Thread thread = new Thread(runnable);
12        thread.start();  // 启动线程
13    }
14}

3. 实现 Callable 接口（配合 ExecutorService 使用）

• 原理：Callable 接口与 Runnable 接口类似，都用于定义线程执行的任务。不同的是，Callable 可以返回任务的执行结果，并且可以抛出异常。通常配合 ExecutorService 来使用，使用 submit() 方法提交任务并获得结果。

• 优点：

  • 可以返回执行结果。
  • 支持异常处理。

• 缺点：需要配合 ExecutorService 使用，相对复杂。

• 示例：

复制
1import java.util.concurrent.*;
2
3class MyCallable implements Callable<String> {
4    @Override
5    public String call() throws Exception {
6        return "Thread executed";
7    }
8}
9
10public class Main {
11    public static void main(String[] args) throws ExecutionException, InterruptedException {
12        ExecutorService executor = Executors.newCachedThreadPool();
13        MyCallable callable = new MyCallable();
14        Future<String> result = executor.submit(callable);
15        System.out.println(result.get());  // 输出线程执行的返回值
16        executor.shutdown();  // 关闭线程池
17    }
18}

4. 通过线程池（ExecutorService）管理线程

• 原理：线程池通过 ExecutorService 来管理线程的生命周期，提交任务，自动分配线程进行执行，并返回任务的执行结果。线程池可以使用 Executor、ExecutorService 和 ThreadPoolExecutor 等类创建。

• 优点：

  • 管理线程的生命周期，避免频繁创建和销毁线程。
  • 支持线程复用，提升性能。
  • 能够控制并发线程的数量，避免系统资源耗尽。

• 示例：

复制
1import java.util.concurrent.*;
2
3public class Main {
4    public static void main(String[] args) {
5        ExecutorService executor = Executors.newFixedThreadPool(2);  // 创建一个固定大小的线程池
6        executor.submit(() -> System.out.println("Task 1"));
7        executor.submit(() -> System.out.println("Task 2"));
8        executor.shutdown();  // 关闭线程池
9    }
10}

5. 使用 ForkJoinPool（适用于大规模并行任务）

• 原理：ForkJoinPool 是 java.util.concurrent 包中的一个类，适用于需要将任务拆分成多个子任务并行执行的情况。ForkJoinPool 使用工作窃取算法，能够在多个处理器之间平衡任务负载，提高效率。

• 优点：适用于大量小任务的并行执行，尤其是需要任务拆分并且能并行处理的情况。

• 示例：

复制
1import java.util.concurrent.*;
2
3class MyTask extends RecursiveTask<Integer> {
4    @Override
5    protected Integer compute() {
6        return 1;  // 假设这是一个复杂的任务，返回结果
7    }
8}
9
10public class Main {
11    public static void main(String[] args) {
12        ForkJoinPool forkJoinPool = new ForkJoinPool();
13        MyTask task = new MyTask();
14        Integer result = forkJoinPool.invoke(task);
15        System.out.println("Result: " + result);
16    }
17}