Comment définir un délai d'attente pour un thread en Java à l'aide d'ExecutorService ?

Comment définir un délai d'attente pour un fil de discussion

Comme soulevé lors de l'enquête initiale, il existe une préoccupation quant à la manière de restreindre l'exécution d'un fil de discussion. temps. L'objectif est de gérer les situations dans lesquelles un thread peut entrer dans une boucle infinie, ce qui entraîne une attente indéfinie du thread parent.

Une solution discutée consiste à utiliser une TimerTask dans la méthode run() du Thread. Cependant, une approche plus efficace consiste à exploiter la classe ExecutorService. Cela fournit un mécanisme pratique pour définir un délai d'attente sur un thread.

Un exemple d'implémentation utilisant ExecutorService peut être illustré comme suit :

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class TimeoutTest {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<string> future = executor.submit(new Task());

        try {
            System.out.println("Started..");
            System.out.println(future.get(3, TimeUnit.SECONDS));
            System.out.println("Finished!");
        } catch (TimeoutException e) {
            future.cancel(true);
            System.out.println("Terminated!");
        }

        executor.shutdownNow();
    }
}

class Task implements Callable<string> {
    @Override
    public String call() throws Exception {
        Thread.sleep(4000); // Simulate a long-running task that takes 4 seconds
        return "Ready!";
    }
}</string></string>

Dans cet exemple, la classe Task encapsule le long- tâche en cours d'exécution. La méthode ExecutorService.submit() est utilisée pour soumettre cette tâche pour exécution. L'objet Future renvoyé par submit() fournit un mécanisme permettant de récupérer le résultat de la tâche.

La méthode Future.get() est appelée avec un argument timeout de 3 secondes. Si la tâche se termine dans ce délai, le résultat est renvoyé. Cependant, si la tâche prend plus de 3 secondes, une TimeoutException est levée. Dans le bloc catch, la tâche est annulée et le message « Terminé ! » Le message est imprimé.

De plus, il est important de noter que dans la tâche de longue durée, une vérification doit être incorporée pour gérer les interruptions, empêchant ainsi la tâche de s'exécuter indéfiniment. Cette vérification peut être implémentée à l'aide de Thread.interrupted().

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!