Java définir un rappel de l'ExecutorService

J'ai un fixedThreadPool que j'utilise pour exécuter un tas de threads de travail à réaliser en parallèle de l'exécution d'une tâche avec de nombreux composants.

Lorsque tous les threads ont fini, j'ai récupérer leurs résultats (qui sont assez grandes) à l'aide d'une méthode (getResult) et les écrire dans un fichier.

En fin de compte, pour économiser de la mémoire et d'être en mesure de voir les résultats intermédiaires, j'aimerais que chaque thread pour écrire son résultat dans le fichier dès qu'il termine l'exécution et ensuite de libérer sa mémoire.

Normalement, je voudrais ajouter du code à cet effet à la fin de la méthode run (). Cependant, certains autres objets de cette classe appelle aussi ces threads, mais NE veulent PAS à la rédaction de leurs résultats dans un fichier au lieu d'utiliser leurs résultats pour effectuer d'autres calculs, qui sont par la suite dans le fichier.

Donc, je me demandais si il est possible d'attacher une fonction de rappel pour le cas d'un fil de finition à l'aide de la ExecutorService. De cette façon, je peux récupérer immédiatement son résultat et de libérer de la mémoire, dans ce scénario, mais de ne pas casser le code, lorsque ces fils sont utilisés dans d'autres scénarios.

Est une chose possible?

OriginalL'auteur Alex | 2012-10-29

  1. 5

    Si vous utilisez Google Goyave est une option, vous pouvez utiliser le ListenableFuture interface de la manière suivante:

    1. Convertir un ExecutorService à un ListeningExecutorService via MoreExecutors.listeningDecorator(existingExecutorService)
    2. La submit(Callable<V>) méthode de ListeningExecutorService a été réduite pour retourner un ListenableFuture, qui est un subinterface de Future.
    3. ListenableFuture a un addListener() méthode de sorte que vous pouvez enregistrer un rappel à exécuter lorsque l'avenir est terminé.

    OriginalL'auteur Peter

  2. 5

    ExecutorService#submit retour FutureTask<T> qui vous permet de récupérer le résultat et la ExecutorService#get méthode de bloquer l'exécution jusqu'à ce que le calcul n'est pas terminé. Exemple -

    ExecutorService executor = Executors.newFixedThreadPool(10);
Future<Long> future = executor.submit(new Callable<Long>(){
       @Override
       public Long call() throws Exception {
           long sum = 0;
           for (long i = 0; i <= 10000000l; i++) {
               sum += i;
           }
           return sum;
       }
});
Long result = future.get();
System.out.println(result);
    Il a en particulier n'a pas envie de changer le run() méthode comme indiqué dans sa question.
    La raison pour laquelle vous pourriez soumettre la tache à un thread séparé est de sorte que vous pouvez éviter de bloquer le thread en cours pour un long calcul, et vous pouvez utiliser le thread en cours pour d'autres choses. Depuis future.get() blocs, il doit être appelé dans une tâche qui est également soumis à la ExecutorService.

    OriginalL'auteur Subhrajyoti Majumder

  3. 2

    Donc, je me demandais si il est possible d'attacher une fonction de rappel pour le cas d'un fil de finition à l'aide de la ExecutorService.

    Pas directement, non, mais il ya un couple de méthodes que vous pourriez faire cela. La manière la plus simple qui vient à l'esprit est d'envelopper votre Runnable dans un autre Runnable qui fait la récolte des résultats.

    Donc, si vous voulez faire quelque chose comme:

    threadPool.submit(new ResultPrinter(myRunnable));
...

private static class ResultPrinter implements Runnable {
    private final MyRunnable myRunnable;
    public ResultPrinter(MyRunnable myRunnable) {
        this.myRunnable = myRunnable;
    }
    public void run() {
        myRunnable.run();
        Results results = myRunnable.getResults();
        //print results;
    }
}
    Le myRunnable.getReulst encore bloque le thread qui s'exécute, il n'est pas de la pure mode asynchrone avec "rappel".
    J'ai supposé que le getResult() appel ne bloquez pas et que le run() méthode stockés tous les résultats dans votre objet. Avoir un get... méthode de bloc n'est pas le meilleur modèle de @JasonMing.

    OriginalL'auteur Gray

  4. 1

    Vous pouvez ajouter un rappel pour quand un thread retourne dans Java 8+ à l'aide de CompletableFuture comme dans l'exemple suivant, où t est le résultat de votre longue calcul,

    int x = 10;
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(x);
CompletableFuture.supplyAsync(() -> {
    T t = new T();
    //do something
    return t;
}).thenApply(t -> {
    //process t
}

    Si vous souhaitez utiliser les callbacks en seulement Java 7, vous pourriez faire quelque chose comme,

    int x = 10;
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(x);
Future<T> result = fixedThreadPool.submit(() -> {
    //do calculation
    return T;
});
fixedThreadPool.submit(() -> {
    long minutesToWait = 5;
    T t = null;
    try {
        t = result.get(minutesToWait, TimeUnit.MINUTES);
    } catch (InterruptedException | ExecutionException | TimeoutException e) {
        LOGGER.error(e);
    }
    if (t != null) {
        //process t
    }
});

    OriginalL'auteur Max

  5. -1

    Oups, vient de trouver une réponse sur StackOverflow:

    Java ExecutorService de rappel sur le thread de résilier

    Merci pour la patience!

    OriginalL'auteur Alex