Comment résoudre l'exception de délai d'expiration de concurrence Java (TimeoutException)

Comment résoudre l'exception de délai d'expiration de concurrence Java (TimeoutException)

Dans la programmation multithread, les opérations simultanées expirent souvent. Lorsque nous devons effectuer une opération de longue durée, si le délai prédéfini est dépassé, une exception de délai d'attente (TimeoutException) doit être levée. Cet article explique comment résoudre les exceptions de délai d'attente de concurrence Java et fournit des exemples de code correspondants.

1. Utiliser Future et ExecutorService

Une solution courante consiste à utiliser Future et ExecutorService de Java. Nous pouvons encapsuler des opérations fastidieuses dans un objet Callable et utiliser ExecutorService pour soumettre la tâche. Ensuite, utilisez la méthode get de Future pour définir le délai d'attente. Si le résultat n'est pas renvoyé dans le délai spécifié, une exception de délai d'attente sera levée.

Voici un exemple de code :

import java.util.concurrent.*;

public class TimeoutExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        // 创建一个Callable任务
        Callable<String> callableTask = new Callable<String>() {
            @Override
            public String call() throws Exception {
                // 模拟一个耗时的操作
                Thread.sleep(5000);
                return "操作完成";
            }
        };

        // 提交任务，并设置超时时间为3秒
        Future<String> future = executorService.submit(callableTask);
        String result = null;
        try {
            result = future.get(3, TimeUnit.SECONDS);
            System.out.println("操作结果：" + result);
        } catch (TimeoutException e) {
            // 超时异常处理
            System.out.println("操作超时");
        } finally {
            // 关闭ExecutorService
            executorService.shutdown();
        }
    }
}

Dans l'exemple de code ci-dessus, nous avons créé un ExecutorService et soumis une tâche Callable à l'aide de sa méthode de soumission. Ensuite, utilisez la méthode get de Future pour définir le délai d'attente sur 3 secondes. Si la tâche n'est pas terminée dans les 3 secondes, une TimeoutException est levée. Enfin, nous captons l'exception de délai d'attente dans le bloc catch et la gérons.

2. Utilisation des méthodes CompletableFuture et CompletableFuture.get

Une autre solution courante consiste à définir le délai d'attente en utilisant la classe CompletableFuture introduite dans Java 8 et sa méthode get.

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class TimeoutExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟一个耗时的操作
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "操作完成";
        });

        String result = null;
        try {
            result = future.get(3, TimeUnit.SECONDS);
            System.out.println("操作结果：" + result);
        } catch (TimeoutException e) {
            // 超时异常处理
            System.out.println("操作超时");
        }
    }
}

Dans l'exemple de code ci-dessus, nous utilisons la méthode supplyAsync de CompletableFuture pour exécuter une méthode Supplier (expression Lambda), qui simule une opération fastidieuse. Ensuite, nous utilisons la méthode get de CompletableFuture pour définir le délai d'attente à 3 secondes.

Que vous utilisiez ExecutorService et Future, ou que CompletableFuture, vous pouvez très bien résoudre le problème de l'exception de délai d'attente de concurrence Java. Dans les applications réelles, choisissez simplement la solution appropriée en fonction de scénarios et de besoins spécifiques.

Résumé

Cet article présente deux manières courantes de résoudre les exceptions de délai d'expiration de concurrence Java, en utilisant respectivement ExecutorService et CompletableFuture. Dans la programmation multithread, les exceptions de délai d'attente sont un problème courant qui doit être traité de manière raisonnable et des solutions appropriées doivent être sélectionnées en fonction des besoins réels. J'espère que cet article sera utile pour résoudre le problème de l'exception de délai d'attente de concurrence.

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!