Concurrence et multithreading en Java : techniques avancées

Concurrence et multithreading en Java : niveau avancé

Le multithreading en Java est l'un des sujets les plus puissants et en même temps les plus complexes. Au niveau débutant, nous utilisons synchronized et Thread, mais pour construire des systèmes performants et évolutifs, une compréhension plus approfondie est nécessaire. Dans cet article, nous allons explorer les mécanismes avancés de concurrence : les pools de threads, ForkJoinPool, la programmation asynchrone avec CompletableFuture, le réglage fin des verrous et la gestion de la mémoire. Ce contenu est destiné aux développeurs déjà familiarisés avec les bases du multithreading.

1. Travail avancé avec les pools de threads : ExecutorService et configuration

L'utilisation de ExecutorService est la norme en développement industriel. Cependant, le Executors.newFixedThreadPool(10) standard ne convient pas toujours. Examinons la configuration fine de ThreadPoolExecutor.

import java.util.concurrent.*;\n\npublic class CustomThreadPool {\n    public static void main(String[] args) {\n        int corePoolSize = 4;\n        int maxPoolSize = 8;\n        long keepAliveTime = 30;\n        TimeUnit unit = TimeUnit.SECONDS;\n        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);\n\n        ThreadPoolExecutor executor = new ThreadPoolExecutor(\n                corePoolSize,\n                maxPoolSize,\n                keepAliveTime,\n                unit,\n                workQueue,\n                new ThreadPoolExecutor.CallerRunsPolicy() // politique de saturation\n        );\n\n        // Surveillance de l'état du pool\n        executor.submit(() -> {\n            System.out.println("Threads actifs : " + executor.getActiveCount());\n            System.out.println("Tâches terminées : " + executor.getCompletedTaskCount());\n        });\n\n        executor.shutdown();\n    }\n}

Paramètres clés :

\n
• corePoolSize — nombre minimal de threads maintenus même sans tâches.
\n
• maxPoolSize — nombre maximal de threads.
\n
• keepAliveTime — durée de vie des threads excédentaires.
\n
• workQueue — file d'attente des tâches. ArrayBlockingQueue avec une taille limitée empêche le débordement mémoire.
\n
• Politique de saturation — que faire si la file est pleine et tous les threads sont occupés. CallerRunsPolicy ralentit le thread appelant.
\n

Pour les tâches I/O longues, il est préférable d'augmenter corePoolSize ; pour les tâches CPU-bound, se baser sur Runtime.getRuntime().availableProcessors().

2. ForkJoinPool et tâches récursives

ForkJoinPool est un pool spécialisé pour les tâches pouvant être divisées en sous-tâches (diviser pour régner). Il utilise efficacement le vol de travail (work stealing).

Exemple : calcul récursif de la somme des éléments d'un tableau.

import java.util.concurrent.RecursiveTask;\nimport java.util.concurrent.ForkJoinPool;\n\npublic class SumTask extends RecursiveTask<Long> {\n    private static final int THRESHOLD = 1000;\n    private final int[] array;\n    private final int start;\n    private final int end;\n\n    public SumTask(int[] array, int start, int end) {\n        this.array = array;\n        this.start = start;\n        this.end = end;\n    }\n\n    @Override\n    protected Long compute() {\n        if (end - start <= THRESHOLD) {\n            long sum = 0;\n            for (int i = start; i < end; i++) {\n                sum += array[i];\n            }\n            return sum;\n        }\n        int mid = (start + end) / 2;\n        SumTask leftTask = new SumTask(array, start, mid);\n        SumTask rightTask = new SumTask(array, mid, end);\n\n        leftTask.fork(); // lancement asynchrone\n        long rightResult = rightTask.compute(); // calculons