Comment Keep-alive travailler avec ThreadPoolExecutor?

Dans le prolongement d'une question posté par moi, je suis en train d'utiliser ThreadPoolExecutor dans ma base de code. Même après plusieurs tentatives pour comprendre à partir de l'API Java doc, je n'ai pas réussi à comprendre clairement la fonctionnalité/le but derrière keepAliveTime des paramètres passés au constructeur. Espérons que quelqu'un peut m'expliquer avec quelques bon exemple.

Extraits de Java doc:

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

keepAliveTime - lorsque le nombre de threads est plus grande que le noyau, c'est le temps maximum que l'excès de threads inactifs va attendre pour les nouvelles tâches avant de s'arrêter.

  • Tout comme un point de terminologie, vous avez utilisé deux fois le mot "œuvre" quand je pense que vous venez de dire "utiliser". Vous n'êtes pas d'essayer de mettre en œuvre ThreadPoolExecutor en écrivant votre propre code de mise en œuvre de l'API - vous êtes tout simplement la création d'un ThreadPoolExecutor et vous voulez savoir comment il va se comporter, non?
  • Oui, vous avez raison. J'ai juste utilisé pour signifier que c'est un nouveau type de mise en œuvre dans ma base de code.
  • Mais ce n'est pas une mise en œuvre de ThreadPoolExecutor. Il est vraiment utile si vous pouvez utiliser la terminologie appropriée en particulier sur un Débordement de Pile.
  • OK bien sûr. Merci pour la correction de moi.
InformationsquelleAutor Gnanam | 2012-04-30
  1. 65

    Supposons que vous avez une base de la taille de 5, et une taille maximale de 15 ans. Pour une raison quelconque, votre piscine devient occupé, et utilise tous les 15 threads disponibles. Finalement, vous exécutez des travaux à faire - si certains de vos fils devenu inactif qu'ils ont terminé leur tâche finale. Donc 10 de ces threads sont autorisés à mourir.

    Cependant, pour éviter de les tuer trop rapidement, vous pouvez spécifier le temps de persistant. Donc, si vous avez spécifié 1 comme le keepAliveTime valeur et TimeUnit.MINUTE comme le unit valeur, chaque thread attendre une minute après qu'il eut fini de l'exécution d'une tâche pour voir si il n'y avait plus de travail à faire. Si elle n'avait toujours pas donné plus de travail, il serait de les laisser se terminer, jusqu'à ce qu'il n'y avait que 5 fils dans la piscine - le "cœur" de la piscine.

    • Si je comprends bien, keepAliveTime est utilisé/efficace "seulement" quand les fils dans la piscine a plus que la taille du noyau. C'est pas applicable quand les fils dans la piscine est en dessous de la taille du noyau.
    • Désolé si cette question est trop basique. Mais pourquoi voulons-nous garder les fils vivant qui a vraiment fini de l'exécution d'une tâche? De toute façon, le nombre maximal de threads (maximumPoolSize) autorisés dans la piscine est limité?
    • Le point de tuer fils est le même que le point d'avoir un pool de threads en premier lieu -- pas de gaspillage inutile de ressources.
    • de sorte que les threads peuvent exécuter une autre tâche, afin d'épargner sur les frais généraux de la création d'un nouveau thread.
    • Merci pour la clarification. Cela signifie donc que, sur mon autre question - keepAliveTime paramètre de sens "seulement" quand les fils dans la piscine a plus que la taille du noyau -- Est ma compréhension de la droite?
    • C'est certainement ma compréhension trop. Ce n'est pas de dire que c'est forcément exact, mais il pourrait au moins être cohérent 🙂
    • Que faut-il réellement dire quand nous thread est inactif. Disons que j'ai créé 10 threads. La tâche soumis à la thread ne contient qu'un seul appel du réseau, sera le fil d'attente pour l'appel du réseau être considérée comme inactive.
    • En supposant par "en attente de l'appel du réseau" vous voulez dire, c'est faire un appel réseau et de blocage pour qu'il soit fini, alors non, il n'est pas inactif: il est bloquer. S'il était libre, il pourrait être donné à une autre tâche. Si c'est bloqué, il ne peut pas être.
    • Merci c'est ce que j'ai demandé
    • mais ça fonctionne vraiment?
    • Est-il quelque chose qui vous fait penser qu'il ne l'est pas?
    • Il peut également être appliqué à la base de threads. À partir de la documentation: By default, the keep-alive policy applies only when there are more than corePoolSize threads. But method {@link #allowCoreThreadTimeOut(boolean)} can be used to apply this time-out policy to core threads as well, so long as the keepAliveTime value is non-zero.
    • J'étais aussi intéressé par la façon dont les threads dans une piscine stockée/supprimé si keepAliveTime est de 0. La réponse est ici: une fois la valeur de zéro sera la cause de l'excès de threads de mettre fin immédiatement après l'exécution de tâches. Et 0 est utilisé dans newFixedThreadPool

    InformationsquelleAutor Jon Skeet
  2. 3

    Ici une description de la Javadoc:

    <dt>Keep-alive times</dt>
 *
 * <dd>If the pool currently has more than corePoolSize threads,
 * excess threads will be terminated if they have been idle for more
 * than the keepAliveTime (see {@link
 * ThreadPoolExecutor#getKeepAliveTime}). This provides a means of
 * reducing resource consumption when the pool is not being actively
 * used. If the pool becomes more active later, new threads will be
 * constructed. This parameter can also be changed dynamically
 * using method {@link ThreadPoolExecutor#setKeepAliveTime}. Using
 * a value of <tt>Long.MAX_VALUE</tt> {@link TimeUnit#NANOSECONDS}
 * effectively disables idle threads from ever terminating prior
 * to shut down.
 * </dd>
 *

    Essentiellement, cela permet de contrôler le nombre de threads à gauche dans le vide de la piscine. Si vous en faites trop petite (pour ce que vous faites), vous allez créer un trop grand nombre de threads. Si vous faites, il est trop grand, vous serez en consommant de la mémoire/threads que vous n'avez pas besoin d'.

    InformationsquelleAutor Francis Upton
  3. 0

    Ici est un exemple de code qui illustre le travail de keepAliveTime
    Comment maximumPoolSize de ThreadPoolExecutor œuvres?

    InformationsquelleAutor Dmitry Krivenko