多线程的四种实现方式

在 Java 中，实现多线程的方式主要有以下四种：继承 Thread 类、实现 Runnable 接口、实现 Callable 接口以及使用线程池。

1. 继承 Thread 类

通过继承 Thread 类并重写其 run() 方法来定义一个新线程。这是最简单直接的方法，但由于 Java 不支持多重继承，继承 Thread 后无法再继承其他类。

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

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

优点：

• 简单易用。
• 可以直接获取当前线程的状态和控制它。

缺点：

• 由于 Java 的单继承机制，不能继承其他类。
• 不适合资源共享，因为每次创建的是一个新的线程实例。

2. 实现 Runnable 接口

实现 Runnable 接口比继承 Thread 更灵活，因为一个类可以实现多个接口。同时，可以更好地资源共享。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

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

优点：

• 更符合面向对象设计的原则（组合而非继承）。
• 可以实现资源共享，因为多个线程可以共享同一个 Runnable 实例。

缺点：

• 无法返回结果或抛出 checked 异常。

3. 实现 Callable 接口

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

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

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            Thread.sleep(1000); // 模拟耗时操作
        }
        return "任务完成";
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            // 获取Callable返回结果
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

优点：

• 可以返回结果。
• 可以抛出 checked 异常。

缺点：

• 稍微复杂一些，需要配合 FutureTask 使用。

4. 使用线程池

线程池是一种实现多线程的高级方式。Java 提供了 ExecutorService 接口来管理线程池。相比手动创建和管理线程，线程池更加高效和可控。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为5的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            executorService.execute(new RunnableTask());
        }

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

class RunnableTask implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
        try {
            Thread.sleep(1000); // 模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

优点：

• 高效管理线程生命周期。
• 可以复用线程，减少创建和销毁线程的开销。
• 提供丰富的线程管理功能，如定时执行、延迟执行等。

缺点：

• 需要学习和理解线程池相关的 API。
• 配置不当可能导致资源浪费或性能问题。

总结

选择哪种方式取决于具体的需求和应用场景。一般来说，推荐使用 Runnable 或 Callable 配合线程池来实现多线程，以获得更好的性能和资源管理。