Comment implémenter la concurrence non bloquante dans la programmation simultanée Java ?

Il est crucial d'obtenir une concurrence non bloquante en Java, qui peut être obtenue des manières suivantes : en utilisant les classes Future et CompletableFuture : Future représente le résultat d'un calcul asynchrone, et CompletableFuture étend Future avec une API plus riche et une utilisation plus pratique. CompletableFuture peut être utilisé pour exécuter des tâches chronophages de manière asynchrone, permettant à l'application de traiter les résultats une fois la tâche terminée tout en continuant à effectuer d'autres tâches, améliorant ainsi la réactivité.

Programmation simultanée Java : implémentation de la concurrence non bloquante

En Java, la mise en œuvre de la concurrence non bloquante est une technologie cruciale car elle améliore les performances et la réactivité de l'application. La concurrence non bloquante permet à plusieurs threads de travailler simultanément sur différentes tâches sans attendre la fin des autres.

Utiliser Future et CompletableFuture

Les classes Future et CompletableFuture de Java sont un excellent moyen d'obtenir une concurrence non bloquante. Future représente le résultat d'un calcul asynchrone, et CompletableFuture est une extension de Future avec une API plus riche et une utilisation plus pratique. Future 和 CompletableFuture 类是实现非阻塞并发的好方法。Future 表示一个异步计算的结果，而 CompletableFuture 是 Future 的扩展，具有更丰富的 API 和更方便的用法。

以下是一个使用 CompletableFuture 实现非阻塞并发的小例子：

import java.util.concurrent.CompletableFuture;

public class NonBlockingExample {

    public static void main(String[] args) {
        // 创建一个 CompletableFuture，用于计算一个质数列表
        CompletableFuture<List<Integer>> primeListFuture = CompletableFuture.supplyAsync(() -> calculatePrimeNumbers(10000));

        // 继续执行其他任务，无需等待质数列表计算完成
        System.out.println("Continuing with other tasks...");

        // 当质数列表计算完成后，处理结果
        primeListFuture.thenAccept(list -> {
            System.out.println("Prime numbers calculated:");
            list.forEach(System.out::println);
        });
    }

    private static List<Integer> calculatePrimeNumbers(int limit) {
        // 模拟计算质数列表的耗时操作
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= limit; i++) {
            if (isPrime(i)) {
                primes.add(i);
            }
        }

        return primes;
    }

    private static boolean isPrime(int number) {
        for (int i = 2; i <= number / 2; i++) {
            if (number % i == 0) {
                return false;
            }
        }

        return true;
    }
}

在这个例子中，calculatePrimeNumbers 方法是一个耗时的操作，代表一个可能需要大量时间的后台任务。通过使用 CompletableFuture

Ce qui suit est un petit exemple d'utilisation de CompletableFuture pour obtenir une concurrence non bloquante : 🎜rrreee🎜Dans cet exemple, la méthode calculatePrimeNumbers est une opération qui prend du temps, représentant un besoin possible Beaucoup de temps passé sur des tâches en arrière-plan. En utilisant CompletableFuture, nous pouvons exécuter cette tâche de manière asynchrone et traiter les résultats une fois terminés sans attendre la fin de la tâche. De cette façon, notre application peut continuer à effectuer d’autres tâches, améliorant ainsi sa réactivité. 🎜

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!