La fixation d'un délai maximal d'exécution d'une méthode/thread

J'ai une méthode, qui écrit sur la base de données. L'exigence est de s'assurer que cette méthode ne s'exécute pas après un certain temps s'est écoulé. S'il revient avant que, alors rien ne devrait être fait.

Une approche de base que je peux penser à est de faire quelque chose comme ça.

public class LimitedRuntime {

    public static void writeToDb(){
            //writes to the database
    }

    public static void main(String[] args) {
        long totalExecutionTime = 8000L;
        long startTime = System.currentTimeMillis();

        while(System.currentTimeMillis() - startTime < totalExecutionTime )
        {
            writeToDb();
        }   
    }
}

Un problème avec cette approche est que, même si la méthode renvoie devant le max de temps d'exécution total, même alors, le programme s'arrête pour attendre le temps de s'écouler.

Comment puis-je faire de mieux (ou peut-être plus correctement) ? Et si nous utilisons Thread, comment pouvons-nous savoir qui de la Thread exécute cette méthode ?

Ce qui est le plus inconscient solution, Δt = t2 - t2 o.O

OriginalL'auteur OneMoreError | 2013-12-10

  1. 20

    Vous pouvez le faire en envoyant votre travail à un exécuteur testamentaire:

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

    Future<?> future = executor.submit(new Runnable() {
        @Override
        public void run() {
            writeToDb();            //       <-- your job
        }
    });

    executor.shutdown();            //       <-- reject all further submissions

    try {
        future.get(8, TimeUnit.SECONDS);  //    <-- wait 8 seconds to finish
    } catch (InterruptedException e) {    //    <-- possible error cases
        System.out.println("job was interrupted");
    } catch (ExecutionException e) {
        System.out.println("caught exception: " + e.getCause());
    } catch (TimeoutException e) {
        future.cancel(true);              //    <-- interrupt the job
        System.out.println("timeout");
    }

    //wait all unfinished tasks for 2 sec
    if(!executor.awaitTermination(2, TimeUnit.SECONDS)){
        //force them to quit by interrupting
        executor.shutdownNow();
    }
}
    Lors de l'interruption du Fil, vous devez vous rappeler que vous avez à ajouter une condition comme if (isInterrupted()) { return; }. Sans cela, le Fil ne sera pas interrompue à tous! Ne sais pas comment il va travailler avec l'interface Runnable...
    Yep, j'ai supposé que le pilote de base de données doit prendre en compte cette.
    Je ne suis pas familier avec ExecutorService. Je vais lire à ce sujet. Btw pouvez-vous juste me dire a) Ce qui se passe au-dessus si la méthode se termine et renvoie devant la max le temps est écoulé ? b) je veux mettre fin à la méthode instantanément une fois le temps limite est dépassée. Pour cela, dois-je utiliser executor.awaitTermination(0, TimeUnit.SECONDS) ?
    a) à l'Avenir, cesse de l'attente de l'emploi à la fin, main() thread continue l'exécution. Dans ce cas particulier d'application vont tout simplement cesser de fumer. b) future.cancel(true) doit mettre fin à la discussion. Le fil doit soutenir la résiliation @bobbel noté. Votre pilote de base de données doit être pris en charge, si le thread n'a de multiples demandes, il doit vérifier les Thread.interrupted() drapeau entre eux.

    OriginalL'auteur Andrey Chaschev

  2. 3

    Il y a aussi un AspectJ solution pour que, avec jcabi-aspects bibliothèque:

    @Timeable(limit = 5, unit = TimeUnit.SECONDS)
public String writeToDb() {
  //writeToDb
}

    Il y a un article qui explique plus loin: Limite De Java De La Méthode Temps D'Exécution

    OriginalL'auteur gvlasov