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

原创已于 2024-10-15 10:43:38 修改 · 649 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Java

于 2024-09-19 15:01:54 首次发布

在 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);
    }
}