Comment utiliser le pool de threads pour implémenter la planification circulaire des tâches dans Java 7

Comment utiliser les pools de threads pour implémenter la planification cyclique des tâches dans Java 7

Introduction :
Lors du développement d'applications Java, l'utilisation de pools de threads peut améliorer l'efficacité de l'exécution des tâches et l'utilisation des ressources. Dans Java 7, le pool de threads peut être utilisé pour implémenter facilement une planification circulaire des tâches. Cet article explique comment utiliser les pools de threads pour implémenter la planification circulaire des tâches dans Java 7 et joint des exemples de code correspondants.

1. Présentation :
Le pool de threads est une structure de traitement multi-thread qui peut réutiliser un nombre fixe de threads, évitant ainsi la création et la destruction fréquentes de threads et améliorant les performances et la stabilité de l'application. En Java, les pools de threads peuvent être créés et gérés à l'aide de la classe ThreadPoolExecutor.

2. Créer un pool de threads :
Dans Java 7, il existe deux manières de créer un pool de threads : utiliser la méthode statique fournie par la classe Executors pour créer un pool de threads, ou créer un pool de threads via le constructeur de ThreadPoolExecutor. classe.

1. Créez un pool de threads à l'aide de la classe Executors :

   ExecutorService executor = Executors.newFixedThreadPool(10);

   Le code ci-dessus crée un pool de threads d'une taille fixe de 10.

2. Utilisez le constructeur de la classe ThreadPoolExecutor pour créer un pool de threads :

   ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, //核心线程数
    10, //最大线程数
    60, //线程池中空闲线程等待任务的最长时间
    TimeUnit.SECONDS, //等待时间单位
    new ArrayBlockingQueue<Runnable>(10) //阻塞队列
   );

   Le code ci-dessus crée un pool de threads avec un nombre de cœurs de 5, un nombre maximum de threads de 10 et un temps d'attente maximum de 60 secondes et utilise un pool de threads avec une taille de file d'attente de blocage limitée de 10.

3. Soumettez la tâche :
Après avoir créé le pool de threads, nous pouvons soumettre la tâche en appelant la méthode perform() ou la méthode submit().

1. Soumettez une tâche à l'aide de la méthodeexecute() :

   executor.execute(new Runnable() {
    @Override
    public void run() {
        //执行任务逻辑
    }
   });

   Le code ci-dessus crée une classe interne anonyme qui implémente l'interface Runnable et la transmet en tant que paramètre à la méthodeexecute(), soumettant ainsi une tâche.

2. Soumettez une tâche à l'aide de la méthode submit() :

   Future<?> future = executor.submit(new Callable<Object>() {
    @Override
    public Object call() throws Exception {
        //执行任务逻辑
        return null;
    }
   });

   Le code ci-dessus crée une classe interne anonyme qui implémente l'interface Callable et la transmet en tant que paramètre à la méthode submit(), soumettant ainsi une tâche. De plus, la méthode submit() renvoie également un objet Future, qui peut être utilisé pour obtenir les résultats de l'exécution de la tâche.

4. Planification cyclique des tâches :
La planification cyclique des tâches peut être réalisée en utilisant une structure de boucle dans la méthode run() de la tâche. Voici un exemple de code :

public class Task implements Runnable {
    private int count;
    private int maxCount;
    
    public Task(int maxCount) {
        this.maxCount = maxCount;
    }
    
    @Override
    public void run() {
        while(count < maxCount) {
            //执行任务逻辑
            count++;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int maxCount = 100;
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        for(int i=0; i<10; i++) {
            executor.execute(new Task(maxCount));
        }
        
        executor.shutdown();
    }
}

Le code ci-dessus crée une classe de tâches nommée Task, qui implémente la planification cyclique des tâches en utilisant une boucle while pour déterminer si le nombre atteint maxCount après chaque exécution de la logique de tâche. En créant un pool de threads dans la méthode main() de la classe Main et en soumettant plusieurs tâches Task, vous pouvez implémenter une planification circulaire des tâches.

5. Résumé :
Cet article explique comment utiliser les pools de threads pour implémenter la planification cyclique des tâches dans Java 7, en créant un pool de threads, en soumettant des tâches et en utilisant une structure de boucle dans la méthode run() de la tâche. Le pool de threads peut améliorer l'efficacité de l'exécution des tâches et l'utilisation des ressources et constitue l'une des technologies couramment utilisées dans le développement d'applications Java. J'espère que grâce à l'introduction de cet article, les lecteurs auront une certaine compréhension de la façon d'utiliser les pools de threads pour implémenter la planification du cycle de tâches dans Java 7 et pourront l'appliquer de manière flexible 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!