Comment mettre en œuvre efficace de timeout en java

Il y a n objet d'effectuer certaines actions. Après l'exécution d'une action d'un horodatage sera mis à jour. Maintenant, je veux mettre en œuvre un délai de fil qui vérifie si un timestamp est plus vieux que par exemple 60 secondes.

Ma première solution a été de le faire avec un fil (tout-boucle + sleep) qui tient une liste avec tous les objets, y compris la dernière heure. Maintenant j'ai le problème qu'il y a un scénario de la pire éventualité où le fil besoins de 59 secondes plus dormir de temps pour se décider pour un délai d'attente.

Je suis à la recherche d'une solution comme une Minuterie où il est possible de mettre à jour le temps de retard.

Des idées?

Je suis la recherche du mal à comprendre votre logique. Pourriez-vous nous montrer un exemple de code pour ce que vous essayez de faire ?
Quelque chose me fait penser que vous souhaitez surveiller certains threads pour un "travail" de l'événement. Vous pouvez utiliser CountDownLatch à cette fin.
Ce qui se passe lorsqu'un objet est terminée dans le temps? Et ce qui se passe quand ils ne le font pas? Ne vous laisser continuer? ou doivent-ils s'arrêter? Il y en a plusieurs options. Pourriez-vous ajouter votre objectif à la question? et vous pouvez obtenir le meilleur ajustement de ce problème.
une autre précision: Quand vous dites "Il y a n objet qui effectuer quelques actions..." je suppose que vous voulez dire "n threads ..." ?

OriginalL'auteur stormsam | 2012-07-24

  1. 2

    Je pense que l'utilisation d'un moniteur de l'objet avec wait/notify est raisonnable (vous pouvez utiliser la Condition avec les attendent/signal si vous utilisez le JDK >= 5)

    idée est simple:

    Thread de travail:

    doYourActualWork();
synchronized(jobFinishedMonitor) {
    updateTimestamp();

    jobFinishedMonitor.notify();
}

    Thread de délai d'attente:

    synchronized(jobFinishedMonitor) {
    while(within60Second(timestamp)) {
        jobFinishedMonitor.wait(60);
    }
    if (within60Second(timestamp)) {
        timeoutHappened=true;
    }
 }
 if (timeoutHappened) {
     //do timeout handling
 }
    Devrait être attendre(60_000) pendant 60 secondes

    OriginalL'auteur Adrian Shum

  2. 1

    Pour la question, il n'est pas clair ce que vous voulez faire avec le délai d'attente. Ici je vous présente deux options pour mettre en œuvre un léger délai d'attente: surveiller vs contrôlée.

    Surveillé Délai

    Pour un temps, vous pouvez utiliser le Timer installation du JDK:

    public TimeoutTask implements TimerTask {
    List<MonitorableObject>  objects;
    public TimeoutTask(List<MonitorableObject> objects) {
        //make sure you can share this collection concurrently, 
        //e.g. copyonwritearraylist
        this.objects = objects;
    }
    public void run() {
       //objects -> filter(isTimeOut(currentTime)) -> do something
    }
}

Timer timer = new Timer();
timer.schedule(new TimeoutTask(myObjectList), 0,60*1000); //repeat each 60secs

    Il y a une construction similaire possible à l'aide d'un ScheduledExecutorService:

    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
//Note that I can use here TimeoutTask b/c TimerTask is a Runnable - 
//this is just for the example. You'd better implement a plain runnable.
scheduler.schedule(new TimeoutTask(myObjectList), 60, TimeUnit.SECONDS);

    Je préfère le ScheduledExecutorService au-dessus de la Timer établissement, comme le SchedulerExecutor pouvez maintenir un pool de threads. Aussi, le sous-jacent de pool de threads peuvent être utilisées pour d'autres opérations en invoquant scheduledExecutorService.execute(...) immédiate de l'exécution en simultané (pas prévu), en faisant un générique exécuteur installation plutôt consacré à la fonction de minuterie.

    Dans les deux cas, vous aurez besoin de prendre des précautions particulières pour amener la valeur de délai d'expiration de vos objets, vous êtes suivi. Généralement, vous utilisez une méthode synchronisée dans l'objet de demander pour le délai d'attente de l'état.

    Appliquées Délai

    La ExecutorService vous fournit une API pour exécuter un ensemble de tâches à l'intérieur d'un délai d'attente. par exemple,

    List<Callable<?>> myTasks = ...;
//populate myTasks with Callable`s that wrap your intended execution

ExecutorService executorService = ... ;

List<Future<?>> results = executorService.invokeAll(myTasks, 60, TimeUnit.SECONDS);

    Après cette méthode retourne, vous pouvez demander à chaque Futur si il a réussi, dans le délai donné.

    OriginalL'auteur maasg

  3. 0

    Interrompre le fil à chaque fois que vous mettez à jour l'horodatage. Ensuite, il sera en boucle, ne trouve rien à faire, le sommeil, et si rien d'autre n'est arrivé à l'horodatage, échéance il. S'il est interrompu un deuxième temps, tant mieux. Et à toutes les époques, il ne faut jamais dormir pendant plus de 60 moins (à l'heure actuelle moins la plus ancienne timestamp).

    OriginalL'auteur user207421