Impossible de faire un pool de filetage en cache avec une limite de taille?

à moins que j'ai manqué quelque chose, la solution à la question originale est simple. Le code suivant implémente le comportement désiré tel que décrit par l'affiche originale. Il générera jusqu'à 5 threads pour travailler sur une file d'attente illimitée et les threads inactifs se termineront après 60 secondes.

tp = new ThreadPoolExecutor(5, 5, 60, TimeUnit.SECONDS,
                    new LinkedBlockingQueue<Runnable>());
tp.allowCoreThreadTimeOut(true);

avait la même question. comme aucune autre réponse ne rassemble tous les problèmes, j'ajoute le mien:

il est maintenant clairement écrit dans docs : si vous utilisez une file d'attente qui ne bloque pas ( LinkedBlockingQueue ) le réglage des threads max n'a aucun effet, seuls les threads core sont utilisés.

:

public class MyExecutor extends ThreadPoolExecutor {

    public MyExecutor() {
        super(4, 4, 5,TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
        allowCoreThreadTimeOut(true);
    }

    public void setThreads(int n){
        setMaximumPoolSize(Math.max(1, n));
        setCorePoolSize(Math.max(1, n));
    }

}

cet exécuteur a:

1. max threads car nous utilisons une file d'attente illimitée. C'est une bonne chose parce qu'une telle file d'attente peut amener l'exécuteur à créer un nombre massif de threads supplémentaires non-core s'il suit sa politique habituelle.

2. Une file d'attente de taille maxi Integer.MAX_VALUE . Submit() lancera RejectedExecutionException si le nombre de tâches en attente dépasse Integer.MAX_VALUE . Je ne suis pas sûr que nous manquerons de mémoire d'abord ou cela arrivera.

3. a 4 noyau threads possible. Les threads de coeur inactifs s'arrêtent automatiquement s'ils sont inactifs pendant 5 secondes.Donc, oui, uniquement sur demande.Le nombre peut être modifié en utilisant la méthode setThreads() .

4. S'assure que le nombre minimum de threads core n'est jamais inférieur à un, ou bien submit() rejettera chaque tâche. Puisque les threads principaux doivent être > = threads max la méthode setThreads() définit les threads max aussi bien, bien que la définition de threads max soit inutile pour une file d'attente non limitée.

dans votre premier exemple, les tâches suivantes sont rejetées parce que AbortPolicy est la valeur par défaut RejectedExecutionHandler . Le ThreadPoolExecutor contient les politiques suivantes, que vous pouvez modifier via la méthode setRejectedExecutionHandler :"

CallerRunsPolicy
AbortPolicy
DiscardPolicy
DiscardOldestPolicy

on dirait que vous voulez du thread caché avec une CallerRunsPolicy.

aucune des réponses ici n'a résolu mon problème, qui avait à voir avec la création d'un nombre limité de connexions HTTP en utilisant le client HTTP D'Apache (3.x version). Comme il m'a fallu quelques heures pour trouver une bonne configuration, je vais partager:

private ExecutorService executor = new ThreadPoolExecutor(5, 10, 60L,
  TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),
  Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());

cela crée un ThreadPoolExecutor qui commence par cinq et tient un maximum de dix threads fonctionnant simultanément en utilisant CallerRunsPolicy pour l'exécution.

Par la Javadoc de ThreadPoolExecutor:

S'il y a plus que corePoolSize mais moins que maximumPoolSize threads en cours d'exécution, un nouveau thread sera créé seulement si la file d'attente est complète . En réglant corePoolSize et maximumPoolSize de la même façon, vous créez un pool de filetage de taille fixe.

(l'Emphase est mienne.)

gigue de réponse est ce que vous voulez, bien que mine de vos réponses autre question. :)

il y a une autre option. Au lieu d'utiliser New SynchronousQueue, vous pouvez utiliser n'importe quelle autre file d'attente, mais vous devez vous assurer que sa taille est 1, de sorte que executorservice sera forcé de créer un nouveau thread.

ne semble pas comme si l'une des réponses répondent réellement à la question - en fait, je ne peux pas voir un moyen de le faire - même si vous sous-classe de PooledExecutorService puisque beaucoup de méthodes/propriétés sont privées par exemple faisant addIfUnderMaximumPoolSize a été protégé, vous pourriez faire ce qui suit:

class MyThreadPoolService extends ThreadPoolService {
    public void execute(Runnable run) {
        if (poolSize() == 0) {
            if (addIfUnderMaximumPoolSize(run) != null)
                return;
        }
        super.execute(run);
    }
}

le plus proche que j'ai eu était celui - ci- mais même cela n'est pas une très bonne solution

new ThreadPoolExecutor(min, max, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()) {
    public void execute(Runnable command) {
        if (getPoolSize() == 0 && getActiveCount() < getMaximumPoolSize()) {        
            super.setCorePoolSize(super.getCorePoolSize() + 1);
        }
        super.execute(command);
    }

    protected void afterExecute(Runnable r, Throwable t) {
         // nothing in the queue
         if (getQueue().isEmpty() && getPoolSize() > min) {
             setCorePoolSize(getCorePoolSize() - 1);
         }
    };
 };

p. S.

C'est ce que vous voulez (du moins je suppose). Pour une explication cochez Jonathan Feinberg réponse

Executors.newFixedThreadPool(int n)

crée un pool de threads qui réutilise un nombre fixe de threads opérant à partir d'une file d'attente partagée sans limite. À tout moment, à la plupart des threads nThreads seront des tâches de traitement actives. Si des tâches supplémentaires sont soumises lorsque tous les threads sont actifs, ils attendront la file d'attente jusqu'à ce qu'un fil est disponible. Si un thread se termine à cause d'une défaillance durant l'exécution avant l'arrêt, un nouveau thread prendra sa place si nécessaire pour exécuter des tâches ultérieures. Les threads dans le pool existeront jusqu'à ce qu'il soit explicitement arrêté.

Voici une autre solution. Je pense que cette solution se comporte comme vous le souhaitez (mais pas fier de cette solution):

final LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>() {
    public boolean offer(Runnable o) {
        if (size() > 1)
            return false;
        return super.offer(o);
    };

    public boolean add(Runnable o) {
        if (super.offer(o))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }
};

RejectedExecutionHandler handler = new RejectedExecutionHandler() {         
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        queue.add(r);
    }
};

dbThreadExecutor =
        new ThreadPoolExecutor(min, max, 60L, TimeUnit.SECONDS, queue, handler);

1. vous pouvez utiliser ThreadPoolExecutor comme suggéré par @sjlee

   Vous pouvez contrôler la taille de la piscine de façon dynamique. Regardez cette question pour plus de détails:

   Dynamique De Pool De Threads

   ou

2. vous pouvez utiliser NEWWORKSTEALINGPOOL API, qui a été introduit avec java 8.

   public static ExecutorService newWorkStealingPool()
   

   crée un pool de threads en utilisant tous les processeurs disponibles comme niveau de parallélisme cible.

par défaut, le niveau de parallélisme est défini au nombre de cœurs CPU de votre serveur. Si vous avez 4 serveur CPU de base, la taille du pool de thread serait de 4. Cette API retourne ForkJoinPool type de ExecutorService et permet de voler le travail des threads inactifs en volant des tâches de busy les threads ForkJoinPool.