Comment utiliser le framework Fork/Join pour la programmation parallèle en programmation simultanée Java ?

Comment utiliser le framework Java Fork/Join pour la programmation parallèle ? Créez une classe de tâches et implémentez l'interface RecursiveAction ou RecursiveTask. Créez un pool Fork/Join et gérez l’exécution des tâches. Appelez la méthode fork() pour soumettre la tâche au pool et la décomposer en sous-tâches. Appelez la méthode join() pour attendre la fin de la tâche et obtenir les résultats (pour RecursiveTask).

Programmation simultanée Java : programmation parallèle à l'aide du framework Fork/Join

Le framework Fork/Join est une bibliothèque Java qui fournit un cadre léger pour exécuter efficacement des tâches parallèles. Il est basé sur un algorithme de vol de travail qui permet aux threads de collaborer sur des tâches, maximisant ainsi l'utilisation des ressources CPU.

Comment utiliser le framework Fork/Join :

1. Créez une classe de tâches : Cette classe doit implémenter java.util.concurrent.RecursiveAction ou java.util. interface concurrent.RecursiveTask . RecursiveAction est utilisé pour effectuer des tâches qui ne renvoient pas de valeur, contrairement à RecursiveTask. java.util.concurrent.RecursiveAction 或 java.util.concurrent.RecursiveTask 接口。RecursiveAction 用于执行不返回值的任务，而 RecursiveTask 则会返回值。
2. 创建一个 Fork/Join 池：使用 java.util.concurrent.ForkJoinPool 创建一个线程池。它将管理 Fork/Join 任务的执行。
3. Fork 任务：调用 fork() 方法将任务提交给 Fork/Join 池。池会将任务分解成更小的子任务，并分配给可用的线程。
4. Join 任务：调用 join()

Créez un pool Fork/Join :

Utilisez java.util.concurrent.ForkJoinPool pour créer un pool de threads. Il gérera l’exécution des tâches Fork/Join.

Tâche Fork :

Appelez la méthode fork() pour soumettre la tâche au pool Fork/Join. Le pool divise les tâches en sous-tâches plus petites et les affecte aux threads disponibles.

Join task : 🎜Appelez la méthode join() et attendez que la tâche se termine. Pour RecursiveTask, il renvoie également la valeur de retour au thread principal. 🎜🎜🎜🎜Exemple pratique : 🎜🎜🎜Supposons que nous ayons une tâche parallèle qui calcule la somme de tous les nombres impairs dans une liste de nombres. Nous pouvons implémenter cela en utilisant le framework Fork/Join comme suit : 🎜

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class OddSumTask extends RecursiveAction {
    private int[] numbers;
    private int start;
    private int end;

    public OddSumTask(int[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        int sum = 0;
        for (int i = start; i < end; i++) {
            if (numbers[i] % 2 != 0) {
                sum += numbers[i];
            }
        }
        System.out.println("Partial sum: " + sum);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个数字列表
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // 创建一个 Fork/Join 池
        ForkJoinPool pool = new ForkJoinPool();

        // 创建一个 OddSumTask
        OddSumTask task = new OddSumTask(numbers, 0, numbers.length);

        // Fork 任务
        pool.invoke(task);
    }
}

🎜L'exécution de ce code ajoutera les nombres impairs dans la liste et imprimera la somme locale calculée par chaque thread. 🎜

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!