java多线程实现方式

目录

                     1. 继承 Thread 类

2. 实现 Runnable 接口

3. 实现 Callable 接口

4. 使用线程池

5. 使用 CompletableFuture（Java 8+）

6. 使用 ForkJoinPool（Java 7+）

7. 使用 Timer 和 TimerTask

8. 使用 ScheduledExecutorService

总结

---

1. 继承 Thread 类

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

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

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start(); // 启动线程
        thread2.start();
    }
}

特点：

• 简单易用。

• 由于 Java 是单继承，继承 Thread 类后会限制扩展其他类

2. 实现 Runnable 接口

通过实现 Runnable 接口并实现 run() 方法，然后将 Runnable 实例传递给 Thread 对象

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

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start(); // 启动线程
        thread2.start();
    }
}

特点：

• 更灵活，因为可以实现多个接口。

• 适合资源共享的场景，多个线程可以共享同一个 Runnable 实例

3. 实现 Callable 接口

Callable 接口与 Runnable 类似，但它可以返回结果并抛出异常。通常与 FutureTask 或线程池一起使用。

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

class MyCallable implements Callable {
    @Override
    public String call() throws Exception {
        return "Thread is running: " + Thread.currentThread().getName();
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        FutureTask futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start(); // 启动线程
        System.out.println(futureTask.get()); // 获取线程执行结果
    }
}

特点：

• 可以返回结果。

• 支持异常处理。

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(3); // 创建固定大小的线程池

        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                System.out.println("Thread is running: " + Thread.currentThread().getName());
            });
        }

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

特点：

• 高效管理线程资源。

• 支持任务队列和线程复用

5. 使用 CompletableFuture（Java 8+）

CompletableFuture 提供了更强大的异步编程能力，支持链式调用和组合多个异步任务

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture.runAsync(() -> {
            System.out.println("Thread is running: " + Thread.currentThread().getName());
        }).join(); // 等待任务完成
    }
}

特点：

• 支持函数式编程风格。

• 可以方便地组合多个异步任务。

6. 使用 ForkJoinPool（Java 7+）

ForkJoinPool 是一种特殊的线程池，适用于分治任务的并行处理。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

class MyTask extends RecursiveAction {
    @Override
    protected void compute() {
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new MyTask()); // 执行任务
    }
}

特点：

• 适合分治算法（如归并排序、快速排序）。

• 自动任务拆分和结果合并。

7. 使用 Timer 和 TimerTask

Timer 和 TimerTask 可以用于定时任务的调度。

import java.util.Timer;
import java.util.TimerTask;

public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Task is running: " + Thread.currentThread().getName());
            }
        }, 1000, 2000); // 延迟 1 秒，每隔 2 秒执行一次
    }
}

特点：

• 适合简单的定时任务。

• 功能有限，不如 ScheduledExecutorService 强大。

8. 使用 ScheduledExecutorService

ScheduledExecutorService 是更强大的定时任务调度工具

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            System.out.println("Task is running: " + Thread.currentThread().getName());
        }, 1, 2, TimeUnit.SECONDS); // 延迟 1 秒，每隔 2 秒执行一次
    }
}

特点：

• 支持更灵活的定时任务调度。

• 功能强大，推荐替代 Timer。

---

总结

Java 提供了多种多线程实现方式，选择取决于具体需求：

• 简单任务：Thread 或 Runnable。

• 需要返回值：Callable 和 FutureTask。

• 高效管理线程：线程池（ExecutorService）。

• 异步编程：CompletableFuture。

• 分治任务：ForkJoinPool。

• 定时任务：ScheduledExecutorService。