Arrête une tâche périodique depuis la tâche elle-même en cours d'exécution dans un ScheduledExecutorService

Est-il un bon moyen pour arrêter la répétition de la tâche à partir de l'intérieur de la tâche elle-même lors de l'exécution dans un ScheduledExecutorService?

Permet de dire, j'ai la tâche suivante:

Future<?> f = scheduledExecutor.scheduleAtFixedRate(new Runnable() {
    int count = 0;
    public void run() {
       System.out.println(count++);
       if (count == 10) {
           //??? cancel self
       }
    }
}, 1, 1, TimeUnit.SECONDS);

De l'extérieur, il est facile d'annuler par f.annuler(), mais comment puis-je arrêter la répétition à l'endroit spécifié? (En passant de l'Avenir par le biais d'un AtomicReference n'est pas sûr, car il y a un potentiel fenêtre lorsque la scheduleAtFixedRate retourne f en retard et la variable est définie en retard, et que la tâche elle-même peut déjà, en voyant une valeur null dans la référence.)

source d'informationauteur akarnokd

11

Lors de la répétition d'une tâche déclenche une Exception ou une Erreur, il est placé dans l'Avenir et la tâche n'est pas répété. Vous pouvez jeter un RuntimeException ou d'Erreur de votre choix.
4

Au lieu d'utiliser un anonyme intérieur de la classe, vous pouvez utiliser un nom de classe qui permet ensuite d'avoir une propriété pour la Future objet que vous obtenez de la Executor lorsque vous planifiez une tâche.
```
abstract class FutureRunnable implements Runnable {

    private Future<?> future;

    /* Getter and Setter for future */

}
```
Lorsque vous planifiez une tâche que vous pouvez ensuite passer le Future à la Runnable.
```
FutureRunnable runnable = new FutureRunnable() {

    public void run() {
        if (/* abort condition */)
            getFuture().cancel(false);
    }

};
Future<?> future = executor.scheduleAtFixedRate(runnable, ...);
runnable.setFuture(future);
```
Peut-être que vous devrez vous assurer que la tâche n'est pas exécutée avant la Future a été fixé, parce que sinon vous obtiendrez une NullPointerException.
2

Il semble que la mauvaise conception de l'Exécutable de savoir quelque chose au sujet de l'exécuteur, il est en cours d'exécution, ou de lever une erreur si atteignant 10 n'est pas un état d'erreur est un hack.

Pouvez-vous faire la boucle à 10 à l'extérieur de la planification et de l'exécution? Cela peut nécessiter l'utilisation d'un non-planification d'exécuteur testamentaire que vous seriez planification manuellement vous-même.

Voici une autre manière, c'est même Thread-safe;

    final Future<?>[] f = {null};
    f[0]=  scheduledExecutor.scheduleAtFixedRate(new Runnable() {
        int count = 0;
        public void run() {

            System.out.println(count++);
            if (count == 10) {
                Future<?> future;
                while(null==(future = f[0])) Thread.yield();//prevent exceptionally bad thread scheduling 
                future.cancel(false);
                return;
                //cancel self
            }
        }
    }, 1, 1, TimeUnit.SECONDS);

Viens de voir ça maintenant... parce que j'ai voulu faire la même chose... ici c'est ma solution, je suppose que c'est thread-safe.

D'abord créer un conteneur pour l'Avenir:

public static class Cancel {
    private ScheduledFuture<?> future;

    public synchronized void setFuture(ScheduledFuture<?> future) {
        this.future = future;
    }

    public synchronized void stop() {
        LOG.debug("cancelling {}", future);
        future.cancel(false);
    }
}

Et le futur code:

    final Cancel controller = new Cancel();

    synchronized (controller) {
        ScheduledFuture<?> future = scheduler.scheduleWithFixedDelay(() -> {
            if (<CONTINUE RUNNING CONDITION) {

            } else {
                //STOP SCHEDULABLE FUTURE
                controller.stop();
            }
        }, startTime, timeBetweenVisbilityChecks);
        controller.setFuture(future);
    }
}

Donc avis comment le stop ne sera pas exigible jusqu'à ce que le futur a été créé et l'avenir a été mis sur le contrôleur.

Garder à l'esprit que l'Exécutable est le anomymous intérieur de la classe et cela va se faire dans un thread différent totalement.

Vous devez vous connecter pour publier un commentaire.