Exécuteur testamentaire de Service - délai de fil

Alors que j'étais à explorer ExecutorService, j'ai rencontré une méthode Future.get() qui accepte le timeout.

La Java doc de cette méthode, dit

Attend, si nécessaire, pour, au plus, le temps donné pour le calcul à effectuer, puis récupère son résultat, si disponible.

Paramètres:

délai la durée maximale d'attente

unité l'unité de temps de la temporisation argument

Selon ma compréhension, nous impose un délai d'attente sur les callable, nous soumettre à la ExecutorService de sorte que, mon callable sera interrompre après le délai spécifié(timeout) a passé

Mais comme par code ci-dessous, la longMethod() semble être en cours d'exécution au-delà du délai(2 secondes), et je suis vraiment confus à comprendre cela. Quelqu'un peut-il svp m'indiquer le bon chemin?

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

public class Timeout implements Callable<String> {

    public void longMethod() {
        for(int i=0; i< Integer.MAX_VALUE; i++) {
            System.out.println("a");
        }
    }

    @Override
    public String call() throws Exception {
        longMethod();
        return "done";
    }


    /**
     * @param args
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();

        try {
            service.submit(new Timeout()).get(2, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}
En plus des réponses, notez que même si la tâche a été interrompue, car il ne vérifie jamais les interrompre drapeau de toute façon, il continuera à courir jusqu'à la fin.

OriginalL'auteur sanbhat | 2013-04-29

  1. 12

    mon callable s'interrompent après le délai spécifié(timeout) a passé

    Pas vrai. La tâche de continuer à exécuter, au lieu de cela, vous aurez une chaîne null après l'expiration du délai.

    Si vous souhaitez l'annuler: 

      timeout.cancel(true) //Timeout timeout = new Timeout();

    P. S. Comme vous l'avez droit maintenant, cette interruption n'aura aucun effet, afin que jamais. Vous n'êtes pas vérifier cela de toute façon.

    Par exemple ce code prend en compte les interruptions:

        private static final class MyCallable implements Callable<String>{

    @Override
    public String call() throws Exception {
        StringBuilder builder = new StringBuilder();
        try{
            for(int i=0;i<Integer.MAX_VALUE;++i){
                builder.append("a");
                Thread.sleep(100);
            }
        }catch(InterruptedException e){
            System.out.println("Thread was interrupted");
        }
        return builder.toString();
    }
}

    Et puis:

            ExecutorService service = Executors.newFixedThreadPool(1);
    MyCallable myCallable = new MyCallable();
    Future<String> futureResult = service.submit(myCallable);
    String result = null;
    try{
        result = futureResult.get(1000, TimeUnit.MILLISECONDS);
    }catch(TimeoutException e){
        System.out.println("No response after one second");
        futureResult.cancel(true);
    }
    service.shutdown();
    Au sein de votre Appelable utiliser Thread.currentThread().isInterrupted() (ou Thread.currentThread().interrompu()) pour vérifier si la Future.annuler a été appelé. Si votre Callables ne sont pas en cours d'exécution longue cela peut ne pas être nécessaire, mais pour de longues Callables cela vous permettra de se fermer correctement le fil si nécessaire.

    OriginalL'auteur Eugene

  2. 2

    Le délai d'attente sur get() est pour combien de temps le "client" va attendre pour l'Avenir pour compléter. Il n'a pas d'incidence sur l'avenir de l'exécution.

    Object result;
int seconds = 0;
while ((result = fut.get.(1, TimeUnit.SECOND)) == null) {
    seconds++;
    System.out.println("Waited " + seconds + " seconds for future";
}

    OriginalL'auteur rolfl

  3. 0

    mon appelable sera interrompre après le délai spécifié(timeout) a passé

    La déclaration ci-dessus est faux, Généralement de l'Avenir.obtenez de blocage. Spécifier le délai d'attente vous permet de l'utiliser dans un non bloquant.

    Cela est utile par exemple dans les applications critiques de temps, si vous avez besoin d'un résultat, dans disons 2 secondes et la réception d'après ce qui signifie que vous ne pouvez pas faire n'importe quoi avec ça.

    OriginalL'auteur shazin