多线程的四种实现方式

时间：2025-03-30 14:54:55

在 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++) {
            (().getName() + " - " + i);
            try {
                (1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                ();
            }
        }
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        (); // 启动线程
    }
}
优点：
  • 简单易用。
  • 可以直接获取当前线程的状态和控制它。
缺点：
  • 由于 Java 的单继承机制，不能继承其他类。
  • 不适合资源共享，因为每次创建的是一个新的线程实例。

2. 实现 Runnable 接口

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

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

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        (); // 启动线程
    }
}
优点：
  • 更符合面向对象设计的原则（组合而非继承）。
  • 可以实现资源共享，因为多个线程可以共享同一个 Runnable 实例。
缺点：
  • 无法返回结果或抛出 checked 异常。

3. 实现 Callable 接口

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

import ;
import ;
import ;

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

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

        try {
            // 获取Callable返回结果
            String result = ();
            (result);
        } catch (InterruptedException | ExecutionException e) {
            ();
        }
    }
}
优点：
  • 可以返回结果。
  • 可以抛出 checked 异常。
缺点：
  • 稍微复杂一些，需要配合 FutureTask 使用。

4. 使用线程池

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

import ;
import ;

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

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

        // 关闭线程池
        ();
    }
}

class RunnableTask implements Runnable {
    @Override
    public void run() {
        (().getName() + " is running.");
        try {
            (1000); // 模拟耗时操作
        } catch (InterruptedException e) {
            ();
        }
    }
}
优点：
  • 高效管理线程生命周期。
  • 可以复用线程，减少创建和销毁线程的开销。
  • 提供丰富的线程管理功能，如定时执行、延迟执行等。
缺点：
  • 需要学习和理解线程池相关的 API。
  • 配置不当可能导致资源浪费或性能问题。

总结

方法 优点 缺点
继承 Thread 类 简单易用 无法继承其他类，不适合资源共享
实现 Runnable 接口 高度灵活，符合面向对象设计 无法返回结果或抛出 checked 异常
实现 Callable 接口 可以返回结果和抛出异常 需要配合 FutureTask 使用
使用线程池（ExecutorService） 高效管理线程生命周期，复用线程，功能丰富 需要理解线程池 API 和正确配置

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

相关文章