我创建了一个线程池来处理任务,处理完任务后,我发现我无法添加并启动其他任务?如何修复它?如果我将执行器更改为executor = new ThreadPoolExecutor(3, 3, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new NamedThreadFactory("timeOutThread")); ,它将正常运行.但是如果由于超时而取消任务,这是否会导致内存泄漏?

ExecutorService executor =   new ThreadPoolExecutor(3,
                    3, 0L,
                    TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(1),
                    new NamedThreadFactory(
                            "timeOutThread")); 
    List<Callable<String>> callableList = new ArrayList<>();
    IntStream.range(0, 3).forEach(index -> {
        callableList.add(() -> request(index));
    });
    List<Future<String>> futureList = executor.invokeAll(callableList, 1, TimeUnit.SECONDS); 
        for (int i = 0; i < futureList.size(); i++) {
            Future<String> future = futureList.get(i);
            try {
                list.add(future.get());
            } catch (CancellationException e) {
                log.info("timeOut task:{}", i);
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }
          Thread.sleep(1000);
    callableList.clear();
    IntStream.range(0, 3).forEach(index -> {
        callableList.add(() -> request(index));
    });
      long start1 = System.currentTimeMillis();
     // Task java.util.concurrent.FutureTask@5fdcaa40 rejected from java.util.concurrent.ThreadPoolExecutor@6dc17b83   
    List<Future<String>> futureList   = executor.invokeAll(callableList, 1, TimeUnit.SECONDS); 
    for (int i = 0; i < futureList.size(); i++) {
        Future<String> future = futureList.get(i);
        try {
            list.add(future.get());
        } catch (CancellationException e) {
            log.info("timeOut Task:{}", i);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }

  public String request() throws InterruptedException { 
    TimeUnit.MILLISECONDS.sleep(200000);
    return "A";
  }

推荐答案

我可以用以下简化代码再现您的错误:

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {

  public static void main(String[] args) throws InterruptedException {
    var pool = new ThreadPoolExecutor(
        3, 3, 0L, TimeUnit.NANOSECONDS, new LinkedBlockingQueue<>(1));
    try {
      System.out.println("Executing first batch of tasks...");
      submitTasks(pool);

      System.out.println("Executing second batch of tasks...");
      submitTasks(pool);
    } finally {
      pool.shutdown();
    }
  }

  private static void submitTasks(ExecutorService executor) throws InterruptedException {
    var tasks = new ArrayList<Callable<Void>>(3);
    for (int i = 0; i < 3; i++) {
      tasks.add(() -> {
        Thread.sleep(2_000L);
        return null;
      });
    }
    executor.invokeAll(tasks);
  }
}

这将产生以下输出:

Executing first batch of tasks...
Executing second batch of tasks...
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@87aac27[Not completed, task = Main$$Lambda$1/0x0000000800c009f0@816f27d] rejected from java.util.concurrent.ThreadPoolExecutor@3e3abc88[Running, pool size = 3, active threads = 0, queued tasks = 1, completed tasks = 3]
        at java.base/java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2070)
        at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:833)
        at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1365)
        at java.base/java.util.concurrent.AbstractExecutorService.invokeAll(AbstractExecutorService.java:247)
        at Main.submitTasks(Main.java:32)
        at Main.main(Main.java:18)

问题是由于队列太小造成的.创建的LinkedBlockingQueue只具有一个容量,但同时将三个任务提交到池中.所以,问题是,为什么它只在第二次呼叫invokeAll时失败?

原因与ThreadPoolExecutor的实现方式有关.第一次创建实例时,不会启动任何核心线程.在提交任务时,它们会缓慢启动.当任务的提交导致线程启动时,该任务将立即被赋予该线程.队列被绕过.因此,当第一次调用invokeAll时,三个核心线程中的每一个都会启动,并且没有任务进入队列.

但是第二次调用invokeAll时,核心线程已经启动.由于提交任务不会导致创建线程,因此任务被放入队列.但队列太小,导致RejectedExecutionException.如果您想知道为什么即使keep-alive time设置为零,核心线程仍处于活动状态,那是因为默认情况下,核心线程不允许由于超时而死亡(您必须显式配置池以允许超时).

通过稍微修改代码,可以看出,延迟启动的核心线程是问题的原因.只需添加:

pool.prestartAllCoreThreads();

在创建池之后,first callinvokeAll现在会以RejectedExecutionException失败.

此外,如果将队列的容量从1更改为3,那么将不再出现RejectedExecutionException.


以下是一些相关的documentation:

任何BlockingQueue都可用于传输和保存提交的任务.此队列的使用与池大小交互:

  • 如果运行的线程少于corePoolSize个,Executor总是倾向于添加新线程,而不是排队.
  • 如果有corePoolSize个或更多线程正在运行,Executor总是倾向于将请求排队,而不是添加新线程.
  • 如果请求无法排队,将创建一个新线程,除非该线程超过maximumPoolSize,在这种情况下,任务将被拒绝.

Java相关问答推荐

一般类型和kotlin阴影Java函数的问题

为什么如果数组列表中有重复项,我的代码SOMETIMES不返回true?

Quarkus keycloat配置不工作.quarkus. keycloak. policy—enforcer. enable = true在. yaml表示中不工作

Java中后期绑定的替代概念

在spring—data中自动发现native—sql查询期间遇到重复的SQL别名[id]

如何判断一个矩阵是否为有框矩阵?

呈现文本和四舍五入矩形时出现的JavaFX窗格白色瑕疵

Spring和可编辑";where";@Query

Tinylog中的滚动文件会在每次应用启动时覆盖日志(log)文件

在添加AdMob时无法为Google Play构建应用程序包:JVM垃圾收集器崩溃和JVM内存耗尽

在settings.gradle.kts和Build.gradle.kts中使用公共变量

如何生成指定范围内的11位序列号?

Java 21中泛型的不兼容更改

为什么mvn编译生命周期阶段不只是编译已更改的java文件?

具有多个分析模式的复杂分隔字符串的正则表达式

当我将JTextField的getText函数与相等的String进行比较时;t返回true

如何在JSP中从select中获取值并将其放入另一个select

Java中计算大n和k值模10^9+7的二项式系数的乘法公式输出错误值

如何使用Jackson读取以方括号开头的JSON?

ANTLR 接受特殊字符,例如 .标识符或表达式中的(点)和 ,(逗号)