Qu'est-ce que la piscine de fil

Lorsque nous avons besoin pour traiter une tâche, vous pouvez créer un nouveau fil, ce qui permet le fil d'exécuter la tâche. Discussion pool de stockage de la piscine est le sens littéral du fil, quand nous devons faire face à une tâche, vous pouvez supprimer un thread du pool de threads pour l'exécution.

Pourquoi avons-nous besoin d'un pool de threads

Tout d'abord, nous devons savoir pas fil fil de piscine créer directement ce inconvénients:

Le premier est le fils de création et de destruction généraux, threads Java sont mis en correspondance avec la création et la destruction de fils considérablement la perte fréquente des performances du système sur les threads du système d'exploitation.
Discussion prendra un peu d'espace mémoire, si nous créons un grand nombre de threads pour effectuer des tâches en même temps, très faible situation mémoire peut se produire.

Afin de résoudre ces deux problèmes que nous introduisons le concept de la piscine de fil, le fil à travers le complexe pour éviter une création fil de répétition destruction de tête provoquée, et peut définir le nombre maximum de threads pour éviter tout en créant un grand nombre de fils conduisent à un dépassement de mémoire.

Utilisez le pool de threads

1. paramètres de base du pool de threads

Je veux maîtriser le pool de threads pool de threads doit d'abord comprendre les paramètres du constructeur:

nom du paramètre	type	sens
corePoolSize	int	Le nombre de fils de noyau
MaxPoolSize	int	Le nombre maximal de fils
KeepAliveTime	longue	Le maintien du temps de survie
WorkQueue	BlockingQueue	file d'attente de stockage tâche
threadFactory	ThreadFactory	Lorsqu'un besoin de pool de threads pour créer un nouveau thread est créé par ThreadFactory
maître	RejectedExecutionHandler	Quand un pool de threads ne peut pas accepter la tâche que vous soumettons pris refuser la politique

Une par une interprétation de ces paramètres sont difficiles à comprendre, et ici je combine un organigramme pour expliquer le pool de threads de traitement:

Lorsque nous soumettons la tâche à la piscine de fil, si le nombre de threads dans le pool de threads est inférieure à corePoolSize, il créera directement un nouveau traitement de tâches fil;

Si le nombre de threads dans le pool de fil a atteint corePoolSize, et la file d'attente magasin est pas plein, la tâche sera stockée dans la file d'attente des tâches WorkQueue;

Si la file d'attente du magasin était plein, mais le nombre de threads n'a pas encore atteint MaxPoolSize, cette fois-ci continuera à créer un thread pour effectuer la tâche. Note: Le nombre de threads dans le pool de threads cette fois-ci a dépassé corePoolSize, plus de fils corePoolSize dans le pool de threads auraient pas été en vie, et quand ils se sont retirés et sont assis sur KeepAliveTime après le temps de jeu, il sera détruit.

Si le nombre de threads ont atteint MaxPoolSize, cette fois-ci si la tâche encore une fois, le pool de threads à prendre Handler refuser la politique nie la tâche spécifiée.

2. L'analyse de plusieurs pool de threads commun

Java fournit plusieurs pool de threads commun pour nous, vous pouvez facilement les passer à travers la classe Huissiers. nous analysons ici ces types de paramètres utilisés par le pool de threads, de comprendre les similitudes et les différences entre ces pool de threads.

newSingleThreadExecutor

Ye Littéralement, ceci est un pool de threads monothread, ses paramètres de configuration sont les suivants (temps de création ne nécessite pas la participation de masse, ici, il fait référence à la participation de masse au niveau du constructeur de pool de threads appelant):

corePoolSize :. 1
maximumPoolSize (la MaxPoolSize) :. 1
KeepAliveTime: 0L
WorkQueue: a LinkedBlockingQueue d'
autres paramètres par défaut

Nous allons à nouveau conformément à la simulation d'organigramme de travail soumis brillant au-dessus, vous savez pourquoi il est un pool de threads d'un seul thread.

Lorsque les missions ont soumis, il crée un thread pour effectuer la tâche, lors de la présentation de la deuxième tâche, puisque la valeur corePoolSize est 1, donc la tâche sera placé dans la file d'attente. Depuis la sélection de la file d'attente des tâches est LinkedBlockingQueue, la structure sous-jacente est la liste, en théorie, peut être stocké nombre presque infini de tâches (la taille par défaut est Integer.MAX_VALUE), il déclenche jamais la file d'attente des tâches est pleine, il ne va pas continuer pour toujours augmenter le fil, le pool de threads peut continuer à travailler un seul thread.

Si seulement parce que le fil se termine de façon anormale, le pool de threads sera créé sur un nouveau fil vers le haut. En bloquant la file d'attente, le pool de threads pour assurer que les tâches sont exécutées de façon séquentielle.

newFixedThreadPool

Ceci est un nombre fixe de threads dans le pool de threads, ses paramètres de configuration sont les suivants:

corePoolSize: n-
maximumPoolSize (le MaxPoolSize): n-
KeepAliveTime: 0L
WorkQueue: un LinkedBlockingQueue
autres paramètres par défaut

Si vous comprenez comment la limite de SingleThreadExecutor qu'un seul thread pour effectuer la tâche, le principe d'un nombre fixe de threads ici est le même, la clé est de définir corePoolSize et MaxPoolSize de la même taille et utiliser la LinkedBlockingQueue capacité presque illimitée

newCachedThreadPool

Peut être mis en cache pool de threads, je comprends que le cache est mis en cache sur le fil, ses paramètres de construction sont les suivants:

corePoolSize: 0
maximumPoolSize (le MaxPoolSize): Integer.MAX_VALUE
KeepAliveTime: 60L
WorkQueue: SynchronousQueue
autres paramètres par défaut

Après en raison corePoolSize est 0, donc la tâche sera soumis au pool de threads directement à la file d'attente de blocage. Aussi, parce que la file d'attente de blocage utilisations SynchronousQueue, il est une tâche non stockées dans la file d'attente, il tâche une fois fil de traitement de tâche répartie, déclenche directement l'organigramme dans le troisième bloc détermine: si le courant est inférieur au nombre de fils sur MaxPoolSize créer un fil. Depuis MaxPoolSize mis une grande valeur, vous pouvez essentiellement créer un thread indéfiniment, prendre une pause dans un numéro spécifique du nombre maximum JVM de fils qui peuvent être créés. Si le fil est inactif 60 secondes d'assignation des tâches ne pas être pool de threads recyclé.

Le pool de threads a quand traiter un grand nombre de tâches asynchrones de courte liaison de meilleures performances, dans son temps libre est pas de piscine de fil, d'économiser les ressources du système.

newScheduledThreadPool

corePoolSize: Custom
maximumPoolSize (le MaxPoolSize): Integer.MAX_VALUE
KeepAliveTime: 0
WorkQueue: DelayedWorkQueue
autres paramètres par défaut

Depuis MaxPoolSize mis Integer.MAX_VALUE, le fil de pool de threads peut créer illimitée, parce que la file d'attente bloquant choisi DelayedWorkQueue, il peut effectuer des tâches périodiquement.

newWorkStealingPool

Ceci est JDK1.8 pool de threads nouvellement ajouté, le fond en utilisant ForkJoinPool. Si vous utilisez les paramètres par défaut est créé, le pool de threads peut créer autant de fils pour réaliser et systèmes pour répondre aux capacités de traitement parallèle. Chaque thread a sa propre file d'attente, si le travail de thread en cours est terminé, il ira à une autre file d'attente de travail « voler » l'exécution des tâches, la possibilité d'utiliser pleinement CPU multi-core.

Alibaba sur la réglementation sur la création d'un pool de threads

Le passage suivant de la manipulation manuelle de développement Java Alibaba, je crois après avoir lu les paramètres ci-dessus et expliquer les similitudes et les différences de divers pool de threads, pas difficile de comprendre les règles à ce sujet:

(Vi) traitement simultané
4. fil Huissiers de piscine [obligatoire] ne sont pas autorisés à créer, mais par ThreadPoolExecutor, cette approche permet aux élèves d'écrire des règles de fonctionnement plus explicite pool de threads, afin d' éviter le risque d'épuisement des ressources.

Description: Executors retour aux inconvénients de la piscine de fil comme suit:
. 1) et FixedThreadPool SingleThreadPool:
longueur de la file d'attente de requête admissible Integer.MAX_VALUE, peut accumuler un grand nombre de demandes, ce qui provoque MOO.
2) CacheThreadPool et ScheduledThreadPool:
vous permet de créer un certain nombre de threads à Integer.MAX_VALUE, peut créer un grand nombre de fils, ce qui OOM.

3. Le nombre de pool de threads à combien est-elle appropriée?

La réponse à ce problème n'est pas fixé, nous pouvons commencer par l'autorité de l'industrie étant donné le nombre de formules pour calculer le pool de threads, puis confirmé par un certain nombre de mesure de pression spécifique.

Des conseils sont donnés par l'industrie de la formule:

Si la tâche est des tâches gourmandes en temps processeur (telles que le cryptage, le calcul de hachage, etc.), le nombre de threads peut être réglé à environ 1-2 fois le nombre de cœurs de processeur.
Si la tâche est des tâches consommatrices de temps de type IO (tels que la lecture et les bases de données d'écriture, fichiers, réseau, etc.), la formule pour le nombre de fils: fils = noyaux CPU * (1 + temps d'attente moyen / temps de traitement moyen)

Ces deux conceptions différentes ont suivi le principe d'essayer de serrer les performances du processeur.

Cinq états 4. Enfilez Piscine

Cinq États pool de threads sont inscrits dans une classe ThreadPoolExecutor, et ils sont:

RUNNING: accepter de nouvelles tâches et de traiter de nouvelles tâches
SHUTDOWN: ne pas accepter de nouvelles tâches, mais se chargera de la file d'attente des tâches
STOP: ne pas accepter la nouvelle tâche, la file d'attente des tâches ne gère pas la tâche d'interruption en cours de traitement
RANGEMENTS: Toutes les tâches sont terminées, workerCount zéro, le fil sera RANGEMENT état et exécuter terminé () méthode de crochet
TERMINÉ: opération terminée () terminée

5. Le principe de fonctionnement du pool de threads

Le regard Let comment créer une nouvelle tâche de traitement de fil, lisez le pool de threads à regarder le principe est simple:

//首先把我们要放在线程里运行的代码在Runnable接口实现类的run方法中封装好

class MyTask implements Runnable {

    @Override
    public void run() {
        System.out.println("处理任务 + 1");
    }
}

//然后创建一个线程，把该Runnable接口实现类作为构造参数传给线程

public class Basic {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask());
        thread.start();
    }
}
//最后调用线程的start方法运行，实际上调用的是Runnable的run方法

Dans les outils de code ci-dessus l'interface Runnable exemple Transmis à la classe de fil, est devenu une variable membre objet thread, le thread en cours d'exécution lorsque la méthode d'exécution appelle l'instance.

Si vous pouvez voir un fil nouvellement créé pour effectuer la tâche, la tâche et le fil couplé ensemble. Le principe clé du pool de threads est qu'il ajoute une file d'attente de blocage, le découplage des tâches et des fils

Dans le pool de threads, il y a le concept d'un travailleur, un peu difficile à expliquer ce concept, vous pouvez simplement compris comme un travailleur est un thread de travail cette tâche dans sa main, lorsque la méthode du pool de threads runWorker () appelant, le thread le traitement d'une tâche, pour plus de détails voir le code ci-dessous

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) {//会到阻塞队列中获取任务
            w.lock();
            //...
            try {
                //执行任务
            } finally {
                //...
                w.unlock();
            }
        }
        //...
    } finally {
        //...
    }
}

Vous pouvez voir le code clé du code dans le pool de threads est une boucle while, la boucle while continuera à obtenir la tâche de file d'attente de blocage pour arriver à l'exécution des tâches.

référence:

réseau de classe Mu « utilities Fun Java accès concurrentiel, UCC compétent, devenir compliquée par généraliste » cours
https://www.oschina.net/question/565065_86540
https://www.cnblogs.com/dolphin0520/p/3932921.html
https://www.cnblogs.com/ok-wolf/p/7761755.html

De l'utilisation du principe, pour explorer le pool de threads Java