La clé pour maîtriser la programmation multithread Java : apprenez à créer quatre pools de threads

La programmation multithread Java est une compétence essentielle dans le développement de logiciels modernes, qui peut améliorer les performances de concurrence et la vitesse de réponse du système. Dans le développement réel, nous devons souvent gérer et contrôler un grand nombre de threads. En tant qu'outil de programmation simultanée important, le pool de threads peut nous aider à gérer efficacement les threads et à améliorer l'utilisation des ressources.

Cet article présentera quatre méthodes de création de pools de threads couramment utilisées en Java et fournira des exemples de code spécifiques pour aider les lecteurs à maîtriser rapidement l'utilisation des pools de threads.

1.FixedThreadPool (pool de threads de taille fixe)

FixedThreadPool est un pool de threads avec un nombre fixe de threads principaux, un nombre maximum de threads illimité et un temps d'inactivité des threads non valide. Lors de la soumission d'une tâche, s'il y a des threads inactifs dans le pool de threads, elle sera exécutée immédiatement ; s'il n'y a pas de threads inactifs, la tâche entrera dans la file d'attente de blocage et attendra. Les pools de threads de taille fixe conviennent à l’exécution de tâches à long terme et à nombre fixe.

Ce qui suit est un exemple de code pour créer un pool de threads à l'aide de FixedThreadPool :

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

2. CachedThreadPool (pool de threads mis en cache)

CachedThreadPool est un numéro de thread principal de 0, le nombre maximum de threads est illimité et le le temps d'inactivité des threads est de 60 secondes. Le pool de threads. Lors de la soumission d'une tâche, s'il y a des threads inactifs dans le pool de threads, elle sera exécutée immédiatement ; s'il n'y a pas de threads inactifs, un nouveau thread sera créé. Lorsque le thread est inactif pendant plus de 60 secondes, il est arrêté et supprimé du pool de threads. Le pool de threads de cache convient à l'exécution d'un grand nombre de tâches à court terme et peut créer et détruire dynamiquement des threads en fonction de la demande.

Ce qui suit est un exemple de code permettant d'utiliser CachedThreadPool pour créer un pool de threads :

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

3. ScheduledThreadPool (pool de threads planifiés)

ScheduledThreadPool est un pool de threads avec un nombre fixe de threads principaux et un nombre maximum illimité de threads. threads, utilisés pour effectuer des tâches de synchronisation ou des tâches récurrentes. Le pool de threads maintient une file d'attente de retard en interne et traite les tâches de manière ordonnée en fonction du temps de retard.

Ce qui suit est un exemple de code qui utilise ScheduledThreadPool pour créer un pool de threads et exécuter des tâches planifiées :

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        
        executorService.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("Task 1 is running.");
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        executorService.scheduleWithFixedDelay(new Runnable() {
            public void run() {
                System.out.println("Task 2 is running.");
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        executorService.shutdown();
    }
}

4 SingleThreadExecutor (pool de threads à un seul thread)

SingleThreadExecutor est un numéro de thread principal de 1, un nombre maximum. de threads de 1, pool de threads avec un temps d'inactivité non valide. Toutes les tâches sont exécutées en série dans le même thread, dans l'ordre premier entré, premier sorti. Le pool de threads monothread convient aux scénarios dans lesquels les tâches doivent être exécutées dans un ordre et un ordre spécifiques.

Ce qui suit est un exemple de code pour utiliser SingleThreadExecutor pour créer un pool de threads :

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

En maîtrisant les quatre méthodes de création de pool de threads ci-dessus, nous pouvons choisir le pool de threads approprié en fonction de différents scénarios, améliorant ainsi les performances de concurrence et la vitesse de réponse. du programme. Dans le développement réel, nous devons également prêter attention aux problèmes de sécurité des threads et aux paramètres raisonnables du pool de threads pour tirer pleinement parti des avantages du pool de threads.

Nous espérons que les exemples de code et les explications fournis dans cet article pourront aider les lecteurs à maîtriser rapidement les compétences d'utilisation des pools de threads dans la programmation multithread Java, afin qu'ils puissent utiliser les pools de threads plus efficacement pour améliorer les performances du programme dans le développement réel.

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!