Package de concurrence Java : quatre pools de threads fournis par Java via les exécuteurs

Les quatre pools de threads de Java newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor

Inconvénients du nouveau Thread

a Les performances des nouveaux objets créés à chaque fois. Le fil est médiocre.
b. Les threads manquent de gestion unifiée, il peut y avoir un nombre illimité de nouveaux threads, se faire concurrence et occuper trop de ressources système, provoquant des plantages ou un MOO.
c. Manque de fonctions supplémentaires, telles que l'exécution planifiée, l'exécution périodique et l'interruption des threads.
Par rapport au nouveau Thread, les avantages des quatre pools de threads fournis par Java sont :
a. Réutilisez les threads existants, réduisez le coût de création et de destruction d'objets et obtenez de bonnes performances.
b. Il peut contrôler efficacement le nombre maximum de threads simultanés, améliorer l'utilisation des ressources système et éviter une concurrence et une congestion excessives des ressources.
c. Fournit des fonctions telles que l'exécution planifiée, l'exécution périodique, le thread unique et le contrôle de concurrence.

Java fournit quatre pools de threads via les exécuteurs, qui sont :
newCachedThreadPool crée un pool de threads pouvant être mis en cache si la longueur du pool de threads dépasse les besoins de traitement, les threads inactifs peuvent être recyclés de manière flexible s'il n'y a pas de recyclage. , créez-en un nouveau.
newFixedThreadPool crée un pool de threads de longueur fixe qui peut contrôler le nombre maximum de threads simultanés qui attendront dans la file d'attente.
newScheduledThreadPool crée un pool de threads de longueur fixe qui prend en charge l'exécution de tâches planifiées et périodiques.
newSingleThreadExecutor crée un pool de threads à thread unique, qui utilisera uniquement un thread de travail unique pour exécuter les tâches, garantissant que toutes les tâches sont exécutées dans l'ordre spécifié (FIFO, LIFO, priorité).

(1). newCachedThreadPool
Crée un pool de threads pouvant être mis en cache si la longueur du pool de threads dépasse les besoins de traitement, les threads inactifs peuvent être recyclés de manière flexible. S'il n'y en a plus. S'il est recyclé, un nouveau fil sera créé. L'exemple de code est le suivant :

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {final int index = i;try {Thread.sleep(index * 1000);} catch (InterruptedException e) {e.printStackTrace();} cachedThreadPool.execute(new Runnable() { @Overridepublic void run() {System.out.println(in
dex);}});}

Le pool de threads est infini Lorsque la deuxième tâche est exécutée, la première tâche est terminée et le thread exécutant la première tâche sera réutilisé sans en créer une nouvelle. fil à chaque fois.

(2). newFixedThreadPool
Crée un pool de threads de longueur fixe qui peut contrôler le nombre maximum de threads simultanés qui attendront dans la file d'attente. L'exemple de code est le suivant :

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

Étant donné que la taille du pool de threads est de 3, chaque tâche est en veille pendant 2 secondes après la sortie de l'index, donc 3 nombres sont imprimés toutes les deux secondes.

Il est préférable de définir la taille du pool de threads de longueur fixe en fonction des ressources système. Tel que Runtime.getRuntime().availableProcessors(). Veuillez vous référer à PreloadDataCache.

(3) newScheduledThreadPool
Créez un pool de threads de longueur fixe pour prendre en charge l'exécution de tâches planifiées et périodiques. L'exemple de code pour une exécution retardée est le suivant : ScheduledExecutorService selectedThreadPool =

Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

signifie une exécution retardée de 3 secondes.

L'exemple de code pour une exécution régulière est le suivant :

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

signifie une exécution toutes les 3 secondes après un délai de 1 seconde.

ScheduledExecutorService est plus sûr et plus puissant que Timer. Il y aura un article séparé pour comparaison plus tard.

(4), newSingleThreadExecutor
Créez un pool de threads à un seul thread, qui utilisera uniquement le seul thread de travail pour exécuter les tâches, en garantissant que toutes les tâches sont dans l'ordre spécifié ( Exécution FIFO, LIFO, prioritaire). L'exemple de code est le suivant :

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

Les résultats sont affichés dans l'ordre, ce qui équivaut à exécuter chaque tâche dans l'ordre.

La plupart des programmes GUI actuels sont monothread. Les threads uniques dans Android peuvent être utilisés pour les opérations de base de données, les opérations sur les fichiers, l'installation par lots d'applications, la suppression par lots d'applications et d'autres opérations qui ne sont pas adaptées à la concurrence mais peuvent provoquer un blocage des E/S et affecter la réponse du thread de l'interface utilisateur.

Le rôle du pool de threads :

Le rôle du pool de threads est de limiter le nombre de threads d'exécution dans le système.
Selon l'environnement du système, le nombre de threads peut être défini automatiquement ou manuellement pour obtenir le meilleur effet de fonctionnement ; moins de ressources système seront gaspillées, et davantage entraînera une congestion et une inefficacité du système. Utilisez le pool de threads pour contrôler le nombre de threads, et les autres threads font la queue. Une fois qu'une tâche est exécutée, la tâche la plus en avant dans la file d'attente est prise et l'exécution commence. S'il n'y a aucun processus en attente dans la file d'attente, cette ressource du pool de threads est en attente. Lorsqu'une nouvelle tâche doit être exécutée, s'il y a des threads de travail en attente dans le pool de threads, elle peut commencer à s'exécuter, sinon elle entre dans la file d'attente ;

Pourquoi utiliser le pool de threads :

1. Réduisez le nombre de créations et de destructions de threads, chaque thread de travail peut être réutilisé et peut effectuer plusieurs tâches.

2. Vous pouvez ajuster le nombre de threads de travail dans le pool de threads en fonction de la capacité du système pour éviter que le serveur ne soit épuisé en raison d'une consommation excessive de mémoire (chaque thread nécessite environ 1 Mo de mémoire et le thread démarre Plus la mémoire est consommée, plus la mémoire sera consommée et éventuellement le système plantera).

L'interface de niveau supérieur du pool de threads en Java est Executor, mais à proprement parler, Executor n'est pas un pool de threads, mais juste un outil pour exécuter des threads. La véritable interface du pool de threads est ExecutorService.

Articles connexes :

Explication détaillée du code graphique du pool de threads en Java

Explication détaillée de l'utilisation du pool de threads en Java programmation simultanée

Vidéos associées :

Tutoriel vidéo sur les applications avancées de la bibliothèque multithread et simultanée Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!