ScheduledExecutorService avec délai variable

Supposons que j'ai une tâche qui est en tirant des éléments de java.util.de façon concomitante.BlockingQueue et leur traitement.

public void scheduleTask(int delay, TimeUnit timeUnit)
{
    scheduledExecutorService.scheduleWithFixedDelay(new Task(queue), 0, delay, timeUnit);
}

Comment puis-je programmer /reprogrammer la tâche si la fréquence peut être modifiée dynamiquement?

L'idée est de prendre un flux de mises à jour de données et de les propager dans le lot d'une interface graphique
L'utilisateur doit être capable de faire varier la fréquence des mises à jour

il n'est pas clair pour moi pourquoi vous êtes en utilisant une file d'attente de blocage. si youe la file d'attente est vide. Je suppose que votre tâche planifiée sera bloqué. est que votre intention? ce sera probablement confondre le planificateur de tâches de synchronisation.
J'ai choisi le ArrayBlockingQueue de la mise en œuvre doit être thread-safe, le respect de la FIFO de commande et d'être borné. Même si le groupe de blocs, il ne faut pas confondre l'ordonnancement des tâches devrait-il?
Vous avez raison de l'utilisation d'un BlockingQueue de mise en œuvre (en fait ScheduledThreadPoolExecutor utilise en interne). Cependant, pourquoi êtes-vous de multiplication de vos mises à jour de l'interface graphique à l'aide d'une minuterie à tous? Pourquoi ne pas le faire en temps réel? Sont-elles trop nombreuses mises à jour? Êtes-vous préoccupé par le Swing fil filature?
Je veux le lot de mises à jour. Donc, en interne, les événements peuvent arriver tous les ms, mais l'interface graphique s'actualisent toutes les 100ms. Je pense que ce sera plus attrayante visuellement et ont moins de ressources de processeur. J'utilise Eclipse RCP au lieu de Balancer.
Plus tard, en double: Comment puis-je modifier le taux ou la durée de la répétition d'une tâche à l'aide de ScheduledExecutorService?

OriginalL'auteur parkr | 2009-10-05

7

Je ne pense pas que vous pouvez changer à un taux fixe de retard. Je pense que vous devez utiliser calendrier() pour effectuer un one-shot, et de programmer de nouveau une fois celle-ci terminée (avec une heure de modification si nécessaire).

Merci - j'ai fait de "report" une variable d'instance et a ajouté une méthode privée pour effectuer les opérations suivantes: while(!executorService.isShutdown) { executorService.annexe(nouvelle Tâche(file d'attente), le retard, TimeUnit.MILLISECONDES); }

OriginalL'auteur Brian Agnew
26

Utilisation schedule(Callable<V>, long, TimeUnit) plutôt que scheduleAtFixedRate ou scheduleWithFixedDelay. Assurez-vous que votre Appelable reporte lui-même ou une nouvelle instance Appelable à un certain moment dans l'avenir. Par exemple:
```
//Create Callable instance to schedule.
Callable<Void> c = new Callable<Void>() {
  public Void call() {
   try { 
     //Do work.
   } finally {
     //Reschedule in new Callable, typically with a delay based on the result
     //of this Callable.  In this example the Callable is stateless so we
     //simply reschedule passing a reference to this.
     service.schedule(this, 5000L, TimeUnit.MILLISECONDS);
   }  
   return null;
  }
}

service.schedule(c);
```
Cette approche permet d'éviter la nécessité d'arrêter et de recréer le ScheduledExecutorService.

Au lieu de Callable<Void> vous pouvez (devez?) utilisation Runnable.
Oui, c'est un juste point de.
Je ne trouve pas la schedule(Callable) pour une fonction de ScheduledExecutorService. Seulement ceux avec tous les paramètres. Pourriez-vous svp m'indiquer où? Ou au moins la correction de l'exemple pour inclure un retard de 0.
docs.oracle.com/javase/8/docs/api/java/util/concurrent/...

OriginalL'auteur Adamski
2

Ne devriez-vous pas être à l'aide de scheduleAtFixedRate si vous essayez de traiter plusieurs tâches de file d'attente avec un intervalle de temps spécifique? scheduleWithFixedDelay ne pourront pas attendre le délai spécifié, puis d'exécuter une tâche de la file d'attente.

Dans les deux cas, la schedule* méthodes dans un ScheduledExecutorService sera de retour d'une ScheduledFuture de référence. Si vous souhaitez modifier le taux, vous pouvez annuler la ScheduledFuture et de reporter la tâche avec un taux différent.

scheduleWithFixedDelay(...) - Crée et exécute une action périodique qui devient activé en premier lieu après le délai initial, et par la suite avec le délai entre la fin d'une exécution et le début de la prochaine. Si toute l'exécution de la tâche rencontre une exception, les exécutions suivantes sont supprimées. Sinon, la tâche ne s'arrêtera par l'annulation ou la résiliation de l'exécuteur testamentaire.
Pouvez-vous donner un exemple de code d'annulation et rééchelonnement? Ce sur toutes les mises à jour en cours?

OriginalL'auteur jarnbjo
0

scheduleWithFixedDelay(...) retourne un RunnableScheduledFuture. Pour la modifier, vous pouvez simplement l'annuler et de le remettre. Pour la modifier, vous pouvez juste envelopper les RunnableScheduledFuture d'esprit d'un nouveau Praticable:
```
new Runnable() {
    public void run() {
        ((RunnableScheduledFuture)future).run();
    }
};
```
OriginalL'auteur sfussenegger

J'ai dû faire récemment à l'aide de ScheduledFuture et n'a pas voulu envelopper Exécutable ou un tel. Voici comment je l'ai fait:

private ScheduledExecutorService scheduleExecutor;
private ScheduledFuture<?> scheduleManager;
private Runnable timeTask;

public void changeScheduleTime(int timeSeconds){
    //change to hourly update
    if (scheduleManager!= null)
    {
        scheduleManager.cancel(true);
    }
    scheduleManager = scheduleExecutor.scheduleAtFixedRate(timeTask, timeSeconds, timeSeconds, TimeUnit.SECONDS);
}

public void someInitMethod() {

    scheduleExecutor = Executors.newScheduledThreadPool(1);    
    timeTask = new Runnable() {
        public void run() {
            //task code here
            //then check if we need to update task time
            if(checkBoxHour.isChecked()){
                changeScheduleTime(3600);
            }
        }
    };

    //instantiate with default time
    scheduleManager = scheduleExecutor.scheduleAtFixedRate(timeTask, 60, 60, TimeUnit.SECONDS);
}

OriginalL'auteur Chibueze Opata

Vous devez vous connecter pour publier un commentaire.