Java多线程中ExecutorService与任务提交的正确实践-java教程-PHP中文网

Java多线程中ExecutorService与任务提交的正确实践

DDD

发布： 2025-11-10 14:12:26

原创

329人浏览过

java多线程中executorservice与任务提交的正确实践

本文深入探讨了Java多线程编程中，当使用`ExecutorService`提交任务时，因不当实现`Thread`子类而导致的任务重复执行和命名混乱问题。通过分析错误示例，明确了在`run()`方法中不应创建新的`Thread`实例的陷阱，并提供了基于`Runnable`接口的规范解决方案，强调了`Thread.currentThread()`的正确用法，以确保任务在线程池中高效、准确地执行。

在Java并发编程中，ExecutorService是管理和执行异步任务的核心工具。它通过线程池机制，有效地减少了线程创建和销毁的开销，提高了程序的响应性和吞吐量。然而，不正确的任务提交方式，尤其是当自定义任务类继承Thread并包含不当逻辑时，可能导致意想不到的行为，例如任务重复执行或线程命名混乱。

问题分析：不当的Thread子类实现

考虑以下一个尝试使用ExecutorService来模拟线程休眠和唤醒的场景。

原始问题代码示例：

立即学习“Java免费学习笔记（深入）”；

sampleThread.java

import java.util.Random;

public class sampleThread extends Thread {
    sampleThread thread; // 成员变量
    Random rand = new Random();

    public void run() {
        thread = new sampleThread(); // 错误：在run()方法中创建新的sampleThread实例
        int randSleep = rand.nextInt(1000);

        // 使用新创建的'thread'实例的名称
        System.out.println(thread.getName() + " is sleeping for " + randSleep + " milliseconds");

        try {
            Thread.sleep(randSleep);
            // 使用新创建的'thread'实例的名称
            System.out.println(thread.getName() + " is NOW AWAKE");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

登录后复制

driver.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class driver {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        List<Future<?>> futArray = new ArrayList<>();
        ExecutorService es = Executors.newFixedThreadPool(6); // 创建一个固定大小的线程池

        sampleThread temp = new sampleThread(); // 创建一个sampleThread实例
        for (int i = 0; i < 120; i++) {
            Future<?> future = es.submit(temp); // 将同一个temp实例提交120次
            futArray.add(future);
        }
        // ... 后续处理，如等待所有任务完成
        es.shutdown(); // 关闭线程池
    }
}

登录后复制

观察到的输出问题： 在上述代码中，程序执行后，可能会观察到最后一个线程的“NOW AWAKE”消息被重复打印多次，例如：

...
Thread-119 is NOW AWAKE
Thread-120 is sleeping for 487 milliseconds
Thread-120 is NOW AWAKE
Thread-120 is NOW AWAKE
Thread-120 is NOW AWAKE
Thread-120 is NOW AWAKE
Thread-120 is NOW AWAKE
Thread-120 is NOW AWAKE

登录后复制

这与预期中每个任务只打印一次“NOW AWAKE”的情况不符。

根本原因分析

问题的核心在于sampleThread类的run()方法中的这一行：thread = new sampleThread();。

ExecutorService的工作方式：当我们将一个sampleThread实例（例如temp）提交给ExecutorService时，线程池中的一个工作线程会负责执行这个temp实例的run()方法。
run()方法内的冗余创建：然而，在temp实例的run()方法内部，又创建了一个全新的sampleThread实例（即new sampleThread()）。这个新创建的实例被赋值给temp对象的成员变量thread。
错误的线程名称引用：随后的System.out.println语句，如thread.getName()，获取的是这个在run()方法内部新创建的、从未被启动的sampleThread实例的名称，而不是当前正在执行run()方法的线程池工作线程的名称。
潜在的复杂交互：虽然Thread.sleep()会阻塞当前正在执行run()方法的线程池工作线程，但run()方法内部创建新Thread对象的行为，以及对同一个temp实例的多次提交，可能在JVM内部导致复杂的线程命名和任务调度行为，最终表现为特定线程名称的重复打印，尤其是在任务完成阶段。

这种设计模式是错误的，因为ExecutorService的目的是让你提供一个“任务”（通常是Runnable或Callable的实现），然后由线程池中的线程来执行这个任务。任务本身不应该在执行时再创建并管理自己的线程。

解决方案：使用Runnable接口

在Java中，当需要定义一个由ExecutorService执行的任务时，最佳实践是实现Runnable或Callable接口，而不是继承Thread类。Runnable接口只定义了一个run()方法，用于封装任务的执行逻辑，而不需要关心线程的创建和管理。

提客AI提词器

「直播、录课」智能AI提词，搭配抖音直播伴侣、腾讯会议、钉钉、飞书、录课等软件等任意软件。

查看详情

修正后的代码示例：

sampleTask.java (更名为sampleTask以区分Thread类)

import java.util.Random;

// 推荐：实现Runnable接口，而不是继承Thread
public class sampleTask implements Runnable {
    private Random rand = new Random(); // 声明为私有成员变量

    @Override // 明确重写Runnable接口的run方法
    public void run() {
        // 获取当前执行此任务的线程的名称，即线程池中的工作线程
        String currentThreadName = Thread.currentThread().getName();
        int randSleep = rand.nextInt(1000);

        System.out.println(currentThreadName + " is sleeping for " + randSleep + " milliseconds");

        try {
            Thread.sleep(randSleep);
            System.out.println(currentThreadName + " is NOW AWAKE");
        } catch (InterruptedException e) {
            // 优雅地处理中断异常，而不是简单地抛出运行时异常
            System.err.println(currentThreadName + " was interrupted while sleeping.");
            // 重新设置中断标志，以便更高层级的代码可以检测到中断
            Thread.currentThread().interrupt();
        }
    }
}

登录后复制

driver.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class driver {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        List<Future<?>> futArray = new ArrayList<>();
        ExecutorService es = Executors.newFixedThreadPool(6); // 创建一个固定大小的线程池

        for (int i = 0; i < 120; i++) {
            // 每次循环创建一个新的sampleTask实例，确保每个任务是独立的
            sampleTask task = new sampleTask(); 
            Future<?> future = es.submit(task); // 提交任务
            futArray.add(future);
        }

        // 等待所有任务完成
        for (Future<?> future : futArray) {
            future.get(); // 阻塞直到任务完成，并获取结果（如果Callable有结果）
        }

        es.shutdown(); // 关闭线程池
        System.out.println("All tasks completed and ExecutorService shut down.");
    }
}

登录后复制

修正后的输出示例：

pool-1-thread-1 is sleeping for 526 milliseconds
pool-1-thread-6 is sleeping for 497 milliseconds
pool-1-thread-4 is sleeping for 565 milliseconds
pool-1-thread-5 is sleeping for 978 milliseconds
pool-1-thread-2 is sleeping for 917 milliseconds
pool-1-thread-3 is sleeping for 641 milliseconds
pool-1-thread-6 is NOW AWAKE
pool-1-thread-6 is sleeping for 847 milliseconds
pool-1-thread-1 is NOW AWAKE
pool-1-thread-1 is sleeping for 125 milliseconds
...
pool-1-thread-3 is NOW AWAKE
All tasks completed and ExecutorService shut down.

登录后复制

可以看到，现在输出的线程名称是线程池分配的名称（如pool-1-thread-X），并且每个任务的“NOW AWAKE”只打印一次，行为符合预期。

关键点与最佳实践

实现Runnable或Callable而非继承Thread：
- 当任务需要由ExecutorService执行时，通常应实现Runnable（无返回值）或Callable（有返回值且可抛出异常）接口。这使得任务逻辑与线程管理解耦。
- 继承Thread类通常只在需要重写Thread的特定行为或直接管理线程生命周期（例如，自定义线程工厂）时使用，这在大多数情况下是不必要的，且容易引入混淆。
正确获取当前执行线程的名称：
- 要获取当前正在执行任务的线程的名称，应使用Thread.currentThread().getName()。这会返回执行run()方法的实际工作线程的名称（例如，来自ExecutorService线程池的线程）。
- 避免在run()方法内部创建新的Thread实例，并试图获取其名称，因为这个新实例可能从未被启动，其名称与实际执行任务的线程无关。
每次提交创建新的任务实例：
- 在循环中提交任务时，通常需要为每次提交创建一个新的Runnable或Callable实例。虽然ExecutorService.submit()可以接受同一个Runnable实例多次，但这可能导致状态共享问题（如果Runnable有可变成员变量）。对于本例，每次都创建新的sampleTask实例是更清晰和安全的选择。
异常处理：
- 在多线程环境中，中断异常InterruptedException是常见的。捕获后，最佳实践是重新设置当前线程的中断标志（Thread.currentThread().interrupt()），以便调用栈上层的代码能够感知到中断，并进行相应的处理。简单地抛出RuntimeException可能会掩盖中断的意图。

总结

正确使用Java的ExecutorService是编写高效、健壮并发程序的关键。核心原则是区分“任务”和“线程”：ExecutorService管理线程，我们提供任务。通过实现Runnable或Callable接口来定义任务，并利用Thread.currentThread()获取当前执行线程的信息，可以避免常见的陷阱，确保任务在线程池中以预期的方式执行。

以上就是Java多线程中ExecutorService与任务提交的正确实践的详细内容，更多请关注php中文网其它相关文章！