Java中实现多线程的几种方式

在 Java 中，可以通过多种方式实现多线程编程，常见的有以下几种方式：

1. 继承 Thread 类

示例代码：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

优点：

• 简单直接，通过继承 Thread 类，重写 run 方法即可创建线程。
• 适合实现轻量级的、多线程的任务。

缺点：

• Java 不支持多继承，如果继承 Thread，就不能继承其他类，灵活性较差。
• 扩展性较弱，难以复用线程逻辑。

2. 实现 Runnable 接口

示例代码：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

优点：

• 可以实现多继承，类可以同时继承其他类和实现 Runnable 接口。
• 线程任务可以与线程控制分离，逻辑更清晰，适合多次复用。

缺点：

• 需要通过 Thread 类显式创建线程对象。

3. 使用 Callable 接口和 Future 接口

Callable 接口类似于 Runnable，但它可以返回结果并抛出异常。

示例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        
        // 等待任务完成并获取结果
        String result = futureTask.get();
        System.out.println(result);
    }
}

优点：

• 可以返回结果并抛出异常，适合有返回值的任务。
• 与 FutureTask 配合，可以实现线程间的结果传递。

缺点：

• 相比 Runnable，稍微复杂一点，需要通过 FutureTask 等类来管理结果。

4. 使用线程池（ExecutorService）

示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(() -> {
            System.out.println("Task 1 running");
        });

        executor.execute(() -> {
            System.out.println("Task 2 running");
        });

        executor.shutdown();
    }
}

优点：

• 提高资源利用率，减少线程创建和销毁的开销。
• 提供线程复用机制，适合处理大量并发任务。
• 通过线程池可以灵活控制线程数量。

缺点：

• 相对复杂，需要理解 ExecutorService 和线程池的管理。
• 需要手动管理线程池的关闭，否则可能导致内存泄漏。

5. 使用 ForkJoinPool 和 ForkJoinTask

ForkJoinPool 适用于并行任务，将任务分成多个子任务并行执行，再将结果合并。

示例代码：

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class MyRecursiveTask extends RecursiveTask<Integer> {
    private final int workload;

    public MyRecursiveTask(int workload) {
        this.workload = workload;
    }

    @Override
    protected Integer compute() {
        if (workload > 1) {
            MyRecursiveTask task1 = new MyRecursiveTask(workload / 2);
            MyRecursiveTask task2 = new MyRecursiveTask(workload / 2);
            task1.fork();
            return task2.compute() + task1.join();
        } else {
            return workload;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        MyRecursiveTask task = new MyRecursiveTask(100);
        int result = forkJoinPool.invoke(task);
        System.out.println("Result: " + result);
    }
}

优点：

• 提供高效的并行执行，适合任务拆分的场景（如大规模计算）。
• 内置负载均衡机制，能够充分利用多核 CPU。

缺点：

• 对于简单任务，使用 ForkJoinPool 会引入额外的复杂性和开销。
• 不适合 I/O 密集型任务，适合 CPU 密集型任务。

结论

• 继承 Thread：简单，但不灵活，限制较多。
• 实现 Runnable：推荐使用，灵活性高，任务与线程分离。
• 使用 Callable 和 Future：适合需要返回值的多线程任务。
• 线程池：适合大量并发任务，资源管理更高效。
• ForkJoinPool：适合计算密集型任务的并行处理。