Comment gérer TimeoutException avec ExecutorService et des contrats à Terme?

J'ai l'exemple de code suivant et disons que MyCallable("B") prend plus d'une seconde pour exécuter, lorsque les autres l'exécution plus rapide d'une seconde. Donc à l'intérieur de ma boucle qui appelle Future.get(), il va lancer une TimeoutException.

public static void main(String[] args) {
    ExecutorService es = Executors.newFixedThreadPool(2);

    List<Future<String>> futures = new ArrayList<Future<String>>();

    futures.add(es.submit(new MyCallable("A")));
    futures.add(es.submit(new MyCallable("B")));
    futures.add(es.submit(new MyCallable("C")));
    futures.add(es.submit(new MyCallable("D")));
    futures.add(es.submit(new MyCallable("E")));

    try {
        for(Future<String> f  : futures) {
            try {
                System.out.println("result " + f.get(1, TimeUnit.SECONDS));
            }
            catch (TimeoutException e) {
                //how do I know which MyCallable() has timed out?
            } catch (ExecutionException e) {
                System.out.println(e.getMessage());
            }
        }
    }
    catch (InterruptedException e) {
        e.printStackTrace();
    }
    finally {
        es.shutdown();
    }
}

Comme prévu chacune des MyCallable() les instances de l'exécution, mais pour une fois que je voudrais effectuer une gestion d'erreur et que cela nécessite de savoir qui Callable est associé avec qui Future.

Est-il un mécanisme pour cette association ou est-il à la hauteur de mes Callable de gérer toutes les erreurs de traitement à l'intérieur c'est call() méthode?

InformationsquelleAutor Brad | 2012-08-27
  1. 0

    Semble que vous pourriez tout simplement maintenir un Map<Future<String>, Callable<String>> au lieu d'un List<Future<String>> et de récupérer l'original Appelable de cette façon.

    Si vous souhaitez obtenir vraiment intelligent, vous pourriez le faire OO de style et d'étendre ThreadPoolExecutor et de créer un Avenir décorateur de classe. Je pense que c'est probablement excessif, mais vous pouvez le faire comme ceci:

    import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;


public class FutureWithCallable<T> implements Future<T> {
    private final Callable<T> callable;
    private final Future<T> wrapped;

    public FutureWithCallable(Future<T> wrapped, Callable<T> callable) {
        this.callable = callable;
        this.wrapped = wrapped;
    }

    public Callable<T> getCallable() {
        return callable;
    }

    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        return wrapped.cancel(mayInterruptIfRunning);
    }

    @Override
    public T get() throws InterruptedException, ExecutionException {
        return wrapped.get();
    }

    @Override
    public T get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return wrapped.get(timeout, unit);
    }

    @Override
    public boolean isCancelled() {
        return wrapped.isCancelled();
    }

    @Override
    public boolean isDone() {
        return wrapped.isDone();
    }
}

    Et puis:

    import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

    public class ExecutorServiceWithCallable extends ThreadPoolExecutor {

        public ExecutorServiceWithCallable(int corePoolSize, int maxPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            super(corePoolSize, maxPoolSize, keepAliveTime, unit, workQueue);
        }

        @Override
        public <T> FutureWithCallable submit(Callable<T> callable) {
            Future<T> future = super.submit(callable);
            return new FutureWithCallable<T>(future, callable);
        }

    }
    • À l'aide de Map<Future<String>, Callable<String>> est l'option la plus simple et fonctionne
    InformationsquelleAutor Joe K
  2. -1

    public class TimeoutException
    s'étend Exception
    Exception levée lorsqu'une opération de blocage arrive à expiration. Le blocage des opérations pour lesquelles un délai d'attente spécifié besoin d'un moyen pour indiquer que le délai d'attente a eu lieu. Pour beaucoup de ces opérations, il est possible de retourner une valeur qui indique le délai d'attente; lorsque cela n'est pas possible ou souhaitable alors TimeoutException doivent être déclarés et jeté.

    InformationsquelleAutor pankaj