Comment utiliser le pool de threads pour implémenter l'exécution de la boucle de tâches et renvoyer le traitement des résultats dans Java 7

Comment utiliser le pool de threads dans Java 7 pour implémenter l'exécution cyclique des tâches et renvoyer le traitement des résultats

En Java, le pool de threads est une technologie de programmation multi-thread importante, qui peut être utilisée lorsque la surcharge de création de threads est élevée. réutilisation et gestion. Grâce au pool de threads, plusieurs tâches peuvent être soumises au pool de threads pour exécution. Le pool de threads maintient un groupe de threads en arrière-plan, planifie et gère l'exécution de ces threads selon des politiques spécifiques. Dans Java 7, l'utilisation des pools de threads est devenue plus simple et plus pratique. Cet article explique comment utiliser le pool de threads dans Java 7 pour implémenter l'exécution cyclique des tâches et renvoyer le traitement des résultats.

1. Créer un pool de threads
Dans Java 7, vous pouvez utiliser la classe ThreadPoolExecutor pour créer un pool de threads. ThreadPoolExecutor fournit une variété de méthodes de construction pour personnaliser le nombre de threads principaux, le nombre maximum de threads, la file d'attente des tâches, la politique de rejet et d'autres paramètres du pool de threads. Ce qui suit est un exemple de code simple pour créer un pool de threads :

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为5的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        // ...
        
        // 关闭线程池
        executorService.shutdown();
    }
}

2. Soumettez la tâche et obtenez le résultat de retour
Après avoir créé le pool de threads, nous pouvons soumettre la tâche au pool de threads pour exécution via la méthode submit() , et transmettez le Future Object pour obtenir les résultats de retour de la tâche. Voici un exemple de code :

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        // 提交任务并获取Future对象
        Future<String> future = executorService.submit(() -> {
            // 任务的具体逻辑
            // 这里以延时1秒返回结果为例
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, World!";
        });
        
        try {
            // 获取任务的返回结果
            String result = future.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        executorService.shutdown();
    }
}

3. Exécution en boucle des tâches
Dans certains scénarios, nous pouvons avoir besoin de parcourir un ensemble de tâches et d'obtenir les résultats de retour de chaque tâche. Vous pouvez utiliser une boucle for pour soumettre des tâches et utiliser une liste pour enregistrer l'objet Future pour chaque tâche. Voici un exemple de code :

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        // 保存每个任务的Future对象
        List<Future<String>> futures = new ArrayList<>();
        
        // 循环执行10个任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            Future<String> future = executorService.submit(() -> {
                // 任务的具体逻辑
                // 这里以延时1秒返回结果为例
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return "Task-" + taskId + " is completed.";
            });
            futures.add(future);
        }
        
        // 获取每个任务的返回结果
        for (Future<String> future : futures) {
            try {
                String result = future.get();
                System.out.println(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        executorService.shutdown();
    }
}

4. Résumé
En utilisant le pool de threads, vous pouvez implémenter l'exécution cyclique des tâches et renvoyer le traitement des résultats dans Java 7. Lors de la création d'un pool de threads, vous pouvez ajuster les paramètres du pool de threads en fonction de besoins spécifiques ; lors de la soumission d'une tâche, vous pouvez soumettre la tâche via la méthode submit() et utiliser l'objet Future pour obtenir le résultat de retour de la tâche. ; lorsque vous devez exécuter la tâche dans une boucle, vous pouvez utiliser une boucle for pour soumettre des tâches et utiliser une liste pour enregistrer l'objet Future pour chaque tâche. En utilisant rationnellement le pool de threads, les ressources système peuvent être pleinement utilisées et l'efficacité d'exécution du programme peut être améliorée.

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!