Eu preciso implementar um conjunto de encadeamentos em Java (java.util.concurrent) cujo número de encadeamentos esteja em algum valor mínimo quando inativo, cresce até um limite superior (mas nunca mais) quando os trabalhos são enviados para ele mais rápido do que terminam de executar e recua para o limite inferior quando todos os trabalhos são concluídos e não são enviados mais trabalhos.

Como você implementaria algo assim? Eu imagino que este seria um cenário de uso bastante comum, mas aparentemente ojava.util.concurrent.Executors Os métodos de fábrica podem criar apenas pools e pools de tamanho fixo que crescem de forma ilimitada quando muitos trabalhos são enviados. oThreadPoolExecutor classe fornececorePoolSize emaximumPoolSize parâmetros, mas a sua documentação parece implicar que a única maneira de ter mais do quecorePoolSize threads ao mesmo tempo é usar uma fila de trabalhos limitada, nesse caso, se vocêmaximumPoolSize tópicos, você receberá rejeições de trabalho que você tem que lidar com você mesmo? Eu vim com isso:

//pool creation
ExecutorService pool = new ThreadPoolExecutor(minSize, maxSize, 500, TimeUnit.MILLISECONDS,
    new ArrayBlockingQueue<Runnable>(minSize));
...

//submitting jobs
for (Runnable job : ...) {
    while (true) {
        try {
            pool.submit(job);
            System.out.println("Job " + job + ": submitted");
            break;
        } catch (RejectedExecutionException e) {
            // maxSize jobs executing concurrently atm.; re-submit new job after short wait
            System.out.println("Job " + job + ": rejected...");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e1) {
            }
        }
    }
}

Eu estou negligenciando alguma coisa? Existe uma maneira melhor de fazer isso? Além disso, dependendo dos requisitos, pode ser problemático que o código acima não termine até pelo menos (eu acho)(total number of jobs) - maxSize trabalhos terminaram. Portanto, se você quiser enviar um número arbitrário de trabalhos para o pool e prosseguir imediatamente sem esperar que algum deles termine, não vejo como você pode fazer isso sem ter um thread de "job sumitting" dedicado que gerencia a fila ilimitada necessária para manter todos os trabalhos enviados. AFAICS, se você estiver usando uma fila ilimitada para o ThreadPoolExecutor, sua contagem de threads nunca crescerá além do corePoolSize.