Comment expirer un fil

Je veux exécuter un thread pendant un certain temps. S'il n'est pas terminé dans ce délai, je veux le tuer, lever une exception ou le gérer d'une manière ou d'une autre. Comment ceci peut être fait?

Une façon de le faire comme je l'ai compris à partir de ce thread est d'utiliser une TimerTask dans la méthode run () du Thread.

Existe-t-il de meilleures solutions pour cela?

 
EDIT: Ajout d'une prime car j'avais besoin d'une réponse plus claire. Le code ExecutorService donné ci-dessous ne résout pas mon problème. Pourquoi devrais-je dormir () après l'exécution (du code - je n'ai aucune poignée sur ce morceau de code)? Si le code est terminé et que sleep () est interrompu, comment cela peut-il être un timeOut?

La tâche qui doit être exécutée n'est pas sous mon contrôle. Il peut s'agir de n'importe quel morceau de code. Le problème est que ce morceau de code peut s'exécuter dans une boucle infinie. Je ne veux pas que cela se produise. Donc, je veux juste exécuter cette tâche dans un thread séparé. Le thread parent doit attendre la fin de ce thread et doit connaître l'état de la tâche (c'est-à-dire s'il a expiré ou si une exception s'est produite ou si c'est un succès). Si la tâche entre dans une boucle infinie, mon thread parent continue d'attendre indéfiniment, ce qui n'est pas une situation idéale.

En effet plutôt utiliser à la ExecutorServiceplace de Timer, voici un SSCCE :

package com.stackoverflow.q2275443;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class Test {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new Task());

        try {
            System.out.println("Started..");
            System.out.println(future.get(3, TimeUnit.SECONDS));
            System.out.println("Finished!");
        } catch (TimeoutException e) {
            future.cancel(true);
            System.out.println("Terminated!");
        }

        executor.shutdownNow();
    }
}

class Task implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(4000); // Just to demo a long running task of 4 seconds.
        return "Ready!";
    }
}

Jouez un peu avec l' timeoutargument dans la Future#get()méthode, par exemple augmentez-le à 5 et vous verrez que le fil se termine. Vous pouvez intercepter le délai d'expiration dans le catch (TimeoutException e)bloc.

Mise à jour: pour clarifier un malentendu conceptuel, le sleep()n'est pas requis. Il est juste utilisé à des fins de démonstration / SSCCE. Faites simplement votre longue tâche à la place de sleep(). Dans votre longue tâche, vous devriez vérifier si le thread n'est pas interrompu comme suit:

while (!Thread.interrupted()) {
    // Do your long running task here.
}

Il n'y a pas de méthode fiable à 100% pour effectuer une tâche ancienne. La tâche doit être écrite avec cette capacité à l'esprit.

Les bibliothèques Java de base aiment ExecutorServiceannuler les tâches asynchrones avec des interrupt()appels sur le thread de travail. Ainsi, par exemple, si la tâche contient une sorte de boucle, vous devez vérifier son état d'interruption à chaque itération. Si la tâche effectue des opérations d'E / S, elles doivent également être interruptibles et leur configuration peut être délicate. Dans tous les cas, gardez à l'esprit que le code doit vérifier activement les interruptions; définir une interruption ne fait rien nécessairement.

Bien sûr, si votre tâche est une simple boucle, vous pouvez simplement vérifier l'heure actuelle à chaque itération et abandonner lorsqu'un délai spécifié s'est écoulé. Un thread de travail n'est pas nécessaire dans ce cas.

Pensez à utiliser une instance d' ExecutorService . Les deux méthodes invokeAll()et invokeAny()sont disponibles avec un timeoutparamètre.

Le thread actuel se bloquera jusqu'à ce que la méthode soit terminée (je ne sais pas si cela est souhaitable) soit parce que la ou les tâches se sont terminées normalement ou que le délai a été atteint. Vous pouvez inspecter le Future(s) retour (s) pour déterminer ce qui s'est passé.

En supposant que le code de thread est hors de votre contrôle:

De la documentation Java mentionnée ci-dessus:

Que faire si un thread ne répond pas à Thread.interrupt?

Dans certains cas, vous pouvez utiliser des astuces spécifiques à l'application. Par exemple, si un thread attend sur un socket connu, vous pouvez fermer le socket pour provoquer le retour immédiat du thread. Malheureusement, il n'y a vraiment aucune technique qui fonctionne en général. Il convient de noter que dans toutes les situations où un thread en attente ne répond pas à Thread.interrupt, il ne répondra pas non plus à Thread.stop. De tels cas incluent des attaques délibérées par déni de service et des opérations d'E / S pour lesquelles thread.stop et thread.interrupt ne fonctionnent pas correctement.

Conclusion:

Assurez-vous que tous les threads peuvent être interrompus, sinon vous avez besoin d'une connaissance spécifique du thread - comme avoir un indicateur à définir. Peut-être pouvez-vous exiger que la tâche vous soit donnée avec le code nécessaire pour l'arrêter - définissez une interface avec une stop()méthode. Vous pouvez également avertir lorsque vous n'avez pas réussi à arrêter une tâche.

BalusC a déclaré:

Mise à jour: pour clarifier un malentendu conceptuel, le sleep () n'est pas requis. Il est juste utilisé à des fins de SSCCE / démonstration. Faites simplement votre longue tâche à la place du sommeil ().

Mais si vous remplacez Thread.sleep(4000);par for (int i = 0; i < 5E8; i++) {}alors il ne se compile pas, car la boucle vide ne lance pas un InterruptedException.

Et pour que le thread soit interruptible, il doit lancer un InterruptedException.

Cela me semble être un problème grave. Je ne vois pas comment adapter cette réponse pour travailler avec une tâche générale de longue durée.

Modifié pour ajouter: j'ai reformulé ceci comme une nouvelle question: [ interrompre un thread après un temps fixe, doit-il lever InterruptedException? ]

Je pense que vous devriez jeter un coup d'œil aux mécanismes de gestion des accès concurrents (les threads s'exécutant dans des boucles infinies ne sonnent pas bien en soi, btw). Assurez-vous de lire un peu sur le sujet "Tuer" ou "arrêter" les discussions .

Ce que vous décrivez ressemble beaucoup à un "rendez-vous", donc vous voudrez peut-être jeter un œil au CyclicBarrier .

Il peut y avoir d'autres constructions (comme l'utilisation de CountDownLatch par exemple) qui peuvent résoudre votre problème (un thread attend avec un délai d'attente pour le verrou, l'autre doit décompter le verrou s'il a fait son travail, ce qui libérerait votre premier thread soit après une temporisation ou lorsque le compte à rebours du verrou est invoqué).

Je recommande généralement deux livres dans ce domaine: la programmation simultanée en Java et la concurrence Java en pratique .

J'ai créé une classe d'aide juste pour cela il y a quelque temps. Fonctionne très bien:

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * TimeOut class - used for stopping a thread that is taking too long
 * @author Peter Goransson
 *
 */
public class TimeOut {

    Thread interrupter;
    Thread target;
    long timeout;
    boolean success;
    boolean forceStop;

    CyclicBarrier barrier;

    /**
     * 
     * @param target The Runnable target to be executed
     * @param timeout The time in milliseconds before target will be interrupted or stopped
     * @param forceStop If true, will Thread.stop() this target instead of just interrupt() 
     */
    public TimeOut(Runnable target, long timeout, boolean forceStop) {      
        this.timeout = timeout;
        this.forceStop = forceStop;

        this.target = new Thread(target);       
        this.interrupter = new Thread(new Interrupter());

        barrier = new CyclicBarrier(2); // There will always be just 2 threads waiting on this barrier
    }

    public boolean execute() throws InterruptedException {  

        // Start target and interrupter
        target.start();
        interrupter.start();

        // Wait for target to finish or be interrupted by interrupter
        target.join();  

        interrupter.interrupt(); // stop the interrupter    
        try {
            barrier.await(); // Need to wait on this barrier to make sure status is set
        } catch (BrokenBarrierException e) {
            // Something horrible happened, assume we failed
            success = false;
        } 

        return success; // status is set in the Interrupter inner class
    }

    private class Interrupter implements Runnable {

        Interrupter() {}

        public void run() {
            try {
                Thread.sleep(timeout); // Wait for timeout period and then kill this target
                if (forceStop) {
                  target.stop(); // Need to use stop instead of interrupt since we're trying to kill this thread
                }
                else {
                    target.interrupt(); // Gracefully interrupt the waiting thread
                }
                System.out.println("done");             
                success = false;
            } catch (InterruptedException e) {
                success = true;
            }


            try {
                barrier.await(); // Need to wait on this barrier
            } catch (InterruptedException e) {
                // If the Child and Interrupter finish at the exact same millisecond we'll get here
                // In this weird case assume it failed
                success = false;                
            } 
            catch (BrokenBarrierException e) {
                // Something horrible happened, assume we failed
                success = false;
            }

        }

    }
}

Cela s'appelle comme ceci:

long timeout = 10000; // number of milliseconds before timeout
TimeOut t = new TimeOut(new PhotoProcessor(filePath, params), timeout, true);
try {                       
  boolean sucess = t.execute(); // Will return false if this times out
  if (!sucess) {
    // This thread timed out
  }
  else {
    // This thread ran completely and did not timeout
  }
} catch (InterruptedException e) {}  

Je vous poste un morceau de code qui montre comment résoudre le problème. Par exemple, je lis un fichier. Vous pouvez utiliser cette méthode pour une autre opération, mais vous devez implémenter la méthode kill () afin que l'opération principale soit interrompue.

J'espère que ça aide

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Main class
 * 
 * @author el
 * 
 */
public class Main {
    /**
     * Thread which perform the task which should be timed out.
     * 
     * @author el
     * 
     */
    public static class MainThread extends Thread {
        /**
         * For example reading a file. File to read.
         */
        final private File fileToRead;
        /**
         * InputStream from the file.
         */
        final private InputStream myInputStream;
        /**
         * Thread for timeout.
         */
        final private TimeOutThread timeOutThread;

        /**
         * true if the thread has not ended.
         */
        boolean isRunning = true;

        /**
         * true if all tasks where done.
         */
        boolean everythingDone = false;

        /**
         * if every thing could not be done, an {@link Exception} may have
         * Happens.
         */
        Throwable endedWithException = null;

        /**
         * Constructor.
         * 
         * @param file
         * @throws FileNotFoundException
         */
        MainThread(File file) throws FileNotFoundException {
            setDaemon(false);
            fileToRead = file;
            // open the file stream.
            myInputStream = new FileInputStream(fileToRead);
            // Instantiate the timeout thread.
            timeOutThread = new TimeOutThread(10000, this);
        }

        /**
         * Used by the {@link TimeOutThread}.
         */
        public void kill() {
            if (isRunning) {
                isRunning = false;
                if (myInputStream != null) {
                    try {
                        // close the stream, it may be the problem.
                        myInputStream.close();
                    } catch (IOException e) {
                        // Not interesting
                        System.out.println(e.toString());
                    }
                }
                synchronized (this) {
                    notify();
                }
            }
        }

        /**
         * The task which should be timed out.
         */
        @Override
        public void run() {
            timeOutThread.start();
            int bytes = 0;
            try {
                // do something
                while (myInputStream.read() >= 0) {
                    // may block the thread.
                    myInputStream.read();
                    bytes++;
                    // simulate a slow stream.
                    synchronized (this) {
                        wait(10);
                    }
                }
                everythingDone = true;
            } catch (IOException e) {
                endedWithException = e;
            } catch (InterruptedException e) {
                endedWithException = e;
            } finally {
                timeOutThread.kill();
                System.out.println("-->read " + bytes + " bytes.");
                isRunning = false;
                synchronized (this) {
                    notifyAll();
                }
            }
        }
    }

    /**
     * Timeout Thread. Kill the main task if necessary.
     * 
     * @author el
     * 
     */
    public static class TimeOutThread extends Thread {
        final long timeout;
        final MainThread controlledObj;

        TimeOutThread(long timeout, MainThread controlledObj) {
            setDaemon(true);
            this.timeout = timeout;
            this.controlledObj = controlledObj;
        }

        boolean isRunning = true;

        /**
         * If we done need the {@link TimeOutThread} thread, we may kill it.
         */
        public void kill() {
            isRunning = false;
            synchronized (this) {
                notify();
            }
        }

        /**
         * 
         */
        @Override
        public void run() {
            long deltaT = 0l;
            try {
                long start = System.currentTimeMillis();
                while (isRunning && deltaT < timeout) {
                    synchronized (this) {
                        wait(Math.max(100, timeout - deltaT));
                    }
                    deltaT = System.currentTimeMillis() - start;
                }
            } catch (InterruptedException e) {
                // If the thread is interrupted,
                // you may not want to kill the main thread,
                // but probably yes.
            } finally {
                isRunning = false;
            }
            controlledObj.kill();
        }
    }

    /**
     * Start the main task and wait for the end.
     * 
     * @param args
     * @throws FileNotFoundException
     */
    public static void main(String[] args) throws FileNotFoundException {
        long start = System.currentTimeMillis();
        MainThread main = new MainThread(new File(args[0]));
        main.start();
        try {
            while (main.isRunning) {
                synchronized (main) {
                    main.wait(1000);
                }
            }
            long stop = System.currentTimeMillis();

            if (main.everythingDone)
                System.out.println("all done in " + (stop - start) + " ms.");
            else {
                System.out.println("could not do everything in "
                        + (stop - start) + " ms.");
                if (main.endedWithException != null)
                    main.endedWithException.printStackTrace();
            }
        } catch (InterruptedException e) {
            System.out.println("You've killed me!");
        }
    }
}

Cordialement

Voici ma classe d'assistance vraiment simple à utiliser pour exécuter ou appeler un morceau de code Java :-)

Ceci est basé sur l'excellente réponse de BalusC

package com.mycompany.util.concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Calling {@link Callable#call()} or Running {@link Runnable#run()} code
 * with a timeout based on {@link Future#get(long, TimeUnit))}
 * @author pascaldalfarra
 *
 */
public class CallableHelper
{

    private CallableHelper()
    {
    }

    public static final void run(final Runnable runnable, int timeoutInSeconds)
    {
        run(runnable, null, timeoutInSeconds);
    }

    public static final void run(final Runnable runnable, Runnable timeoutCallback, int timeoutInSeconds)
    {
        call(new Callable<Void>()
        {
            @Override
            public Void call() throws Exception
            {
                runnable.run();
                return null;
            }
        }, timeoutCallback, timeoutInSeconds); 
    }

    public static final <T> T call(final Callable<T> callable, int timeoutInSeconds)
    {
        return call(callable, null, timeoutInSeconds); 
    }

    public static final <T> T call(final Callable<T> callable, Runnable timeoutCallback, int timeoutInSeconds)
    {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        try
        {
            Future<T> future = executor.submit(callable);
            T result = future.get(timeoutInSeconds, TimeUnit.SECONDS);
            System.out.println("CallableHelper - Finished!");
            return result;
        }
        catch (TimeoutException e)
        {
            System.out.println("CallableHelper - TimeoutException!");
            if(timeoutCallback != null)
            {
                timeoutCallback.run();
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        catch (ExecutionException e)
        {
            e.printStackTrace();
        }
        finally
        {
            executor.shutdownNow();
            executor = null;
        }

        return null;
    }

}

L'extrait de code suivant démarrera une opération dans un thread séparé, puis attendra jusqu'à 10 secondes pour que l'opération se termine. Si l'opération ne se termine pas à temps, le code tentera d'annuler l'opération, puis poursuivra son chemin joyeux. Même si l'opération ne peut pas être annulée facilement, le thread parent n'attendra pas la fin du thread enfant.

ExecutorService executorService = getExecutorService();
Future<SomeClass> future = executorService.submit(new Callable<SomeClass>() {
    public SomeClass call() {
        // Perform long-running task, return result. The code should check
        // interrupt status regularly, to facilitate cancellation.
    }
});
try {
    // Real life code should define the timeout as a constant or
    // retrieve it from configuration
    SomeClass result = future.get(10, TimeUnit.SECONDS);
    // Do something with the result
} catch (TimeoutException e) {
    future.cancel(true);
    // Perform other error handling, e.g. logging, throwing an exception
}

La getExecutorService()méthode peut être mise en œuvre de plusieurs façons. Si vous n'avez pas d'exigences particulières, vous pouvez simplement demander Executors.newCachedThreadPool()un pool de threads sans limite supérieure sur le nombre de threads.

Une chose que je n'ai pas vue mentionnée est que tuer les threads est généralement une mauvaise idée. Il existe des techniques pour rendre les méthodes threadées proprement abandonnées , mais c'est différent de simplement tuer un thread après un délai d'expiration.

Le risque avec ce que vous proposez est que vous ne savez probablement pas dans quel état sera le thread lorsque vous le tuerez - vous risquez donc d'introduire de l'instabilité. Une meilleure solution consiste à vous assurer que votre code threadé ne se bloque pas lui-même ou qu'il répond bien à une demande d'abandon.

Excellente réponse de BalusC:

mais juste pour ajouter que le timeout lui-même n'interrompt pas le thread lui-même. même si vous vérifiez avec ((Thread.interrupted ()) dans votre tâche. si vous voulez vous assurer que le thread est arrêté, vous devez également vous assurer que future.cancel () est invoqué lorsque l'exception d'expiration est interceptée.

package com.stackoverflow.q2275443; 

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;


public class Test { 
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new Task());

        try { 
            System.out.println("Started..");
            System.out.println(future.get(3, TimeUnit.SECONDS));
            System.out.println("Finished!");
        } catch (TimeoutException e) {
            //Without the below cancel the thread will continue to live 
            // even though the timeout exception thrown.
            future.cancel();
            System.out.println("Terminated!");
        } 

        executor.shutdownNow();
    } 
} 

class Task implements Callable<String> {
    @Override 
    public String call() throws Exception {
      while(!Thread.currentThread.isInterrupted()){
          System.out.println("Im still running baby!!");
      }          
    } 
} 

Je pense que la réponse dépend principalement de la tâche elle-même.

• Est-ce qu'il fait une tâche encore et encore?
• Est-il nécessaire que le délai interrompt une tâche en cours d'exécution immédiatement après son expiration?

Si la première réponse est oui et la seconde est non, vous pouvez rester aussi simple que cela:

public class Main {

    private static final class TimeoutTask extends Thread {
        private final long _timeoutMs;
        private Runnable _runnable;

        private TimeoutTask(long timeoutMs, Runnable runnable) {
            _timeoutMs = timeoutMs;
            _runnable = runnable;
        }

        @Override
        public void run() {
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() < (start + _timeoutMs)) {
                _runnable.run();
            }
            System.out.println("execution took " + (System.currentTimeMillis() - start) +" ms");
        }

    }

    public static void main(String[] args) throws Exception {
        new TimeoutTask(2000L, new Runnable() {

            @Override
            public void run() {
                System.out.println("doing something ...");
                try {
                    // pretend it's taking somewhat longer than it really does
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }
}

Si ce n'est pas une option, veuillez restreindre vos exigences - ou montrer du code.

Je cherchais un ExecutorService qui peut interrompre tous les Runnables expirés exécutés par lui, mais n'en ai trouvé aucun. Après quelques heures, j'en ai créé un comme ci-dessous. Cette classe peut être modifiée pour améliorer la robustesse.

public class TimedExecutorService extends ThreadPoolExecutor {
    long timeout;
    public TimedExecutorService(int numThreads, long timeout, TimeUnit unit) {
        super(numThreads, numThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(numThreads + 1));
        this.timeout = unit.toMillis(timeout);
    }

    @Override
    protected void beforeExecute(Thread thread, Runnable runnable) {
        Thread interruptionThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // Wait until timeout and interrupt this thread
                    Thread.sleep(timeout);
                    System.out.println("The runnable times out.");
                    thread.interrupt();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        interruptionThread.start();
    }
}

Usage:

public static void main(String[] args) {

    Runnable abcdRunnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("abcdRunnable started");
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                // logger.info("The runnable times out.");
            }
            System.out.println("abcdRunnable ended");
        }
    };

    Runnable xyzwRunnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("xyzwRunnable started");
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                // logger.info("The runnable times out.");
            }
            System.out.println("xyzwRunnable ended");
        }
    };

    int numThreads = 2, timeout = 5;
    ExecutorService timedExecutor = new TimedExecutorService(numThreads, timeout, TimeUnit.SECONDS);
    timedExecutor.execute(abcdRunnable);
    timedExecutor.execute(xyzwRunnable);
    timedExecutor.shutdown();
}

Maintenant, je rencontre un problème comme celui-ci. Il arrive de décoder l'image. Le processus de décodage prend trop de temps pour que l'écran reste noir. l ajouter un contrôleur de temps: lorsque le temps est trop long, puis surgissez du fil actuel. Ce qui suit est le diff:

   ExecutorService executor = Executors.newSingleThreadExecutor();
   Future<Bitmap> future = executor.submit(new Callable<Bitmap>() {
       @Override
       public Bitmap call() throws Exception {
       Bitmap bitmap = decodeAndScaleBitmapFromStream(context, inputUri);// do some time consuming operation
       return null;
            }
       });
       try {
           Bitmap result = future.get(1, TimeUnit.SECONDS);
       } catch (TimeoutException e){
           future.cancel(true);
       }
       executor.shutdown();
       return (bitmap!= null);

J'ai eu le même problème. J'ai donc trouvé une solution simple comme celle-ci.

public class TimeoutBlock {

 private final long timeoutMilliSeconds;
    private long timeoutInteval=100;

    public TimeoutBlock(long timeoutMilliSeconds){
        this.timeoutMilliSeconds=timeoutMilliSeconds;
    }

    public void addBlock(Runnable runnable) throws Throwable{
        long collectIntervals=0;
        Thread timeoutWorker=new Thread(runnable);
        timeoutWorker.start();
        do{ 
            if(collectIntervals>=this.timeoutMilliSeconds){
                timeoutWorker.stop();
                throw new Exception("<<<<<<<<<<****>>>>>>>>>>> Timeout Block Execution Time Exceeded In "+timeoutMilliSeconds+" Milli Seconds. Thread Block Terminated.");
            }
            collectIntervals+=timeoutInteval;           
            Thread.sleep(timeoutInteval);

        }while(timeoutWorker.isAlive());
        System.out.println("<<<<<<<<<<####>>>>>>>>>>> Timeout Block Executed Within "+collectIntervals+" Milli Seconds.");
    }

    /**
     * @return the timeoutInteval
     */
    public long getTimeoutInteval() {
        return timeoutInteval;
    }

    /**
     * @param timeoutInteval the timeoutInteval to set
     */
    public void setTimeoutInteval(long timeoutInteval) {
        this.timeoutInteval = timeoutInteval;
    }
}

Garantit que si le bloc ne s'est pas exécuté dans le délai imparti. le processus se terminera et lèvera une exception.

exemple :

try {
        TimeoutBlock timeoutBlock = new TimeoutBlock(10 * 60 * 1000);//set timeout in milliseconds
        Runnable block=new Runnable() {

            @Override
            public void run() {
                //TO DO write block of code 
            }
        };

        timeoutBlock.addBlock(block);// execute the runnable block 

    } catch (Throwable e) {
        //catch the exception here . Which is block didn't execute within the time limit
    }

Dans la solution proposée par BalusC , le thread principal restera bloqué pendant la période de temporisation. Si vous disposez d'un pool de threads avec plusieurs threads, vous aurez besoin du même nombre de threads supplémentaires qui utiliseront Future.get (long timeout, TimeUnit unit) blocking call pour attendre et fermer le thread s'il dépasse le délai d'expiration.

Une solution générique à ce problème consiste à créer un décorateur ThreadPoolExecutor qui peut ajouter la fonctionnalité de délai d'expiration. Cette classe Decorator doit créer autant de threads que ThreadPoolExecutor, et tous ces threads doivent être utilisés uniquement pour attendre et fermer ThreadPoolExecutor.

La classe générique doit être implémentée comme ci-dessous:

import java.util.List;
import java.util.concurrent.*;

public class TimeoutThreadPoolDecorator extends ThreadPoolExecutor {


    private final ThreadPoolExecutor commandThreadpool;
    private final long timeout;
    private final TimeUnit unit;

    public TimeoutThreadPoolDecorator(ThreadPoolExecutor threadpool,
                                      long timeout,
                                      TimeUnit unit ){
        super(  threadpool.getCorePoolSize(),
                threadpool.getMaximumPoolSize(),
                threadpool.getKeepAliveTime(TimeUnit.MILLISECONDS),
                TimeUnit.MILLISECONDS,
                threadpool.getQueue());

        this.commandThreadpool = threadpool;
        this.timeout=timeout;
        this.unit=unit;
    }

    @Override
    public void execute(Runnable command) {
        super.execute(() -> {
            Future<?> future = commandThreadpool.submit(command);
            try {
                future.get(timeout, unit);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (ExecutionException | TimeoutException e) {
                throw new RejectedExecutionException(e);
            } finally {
                future.cancel(true);
            }
        });
    }

    @Override
    public void setCorePoolSize(int corePoolSize) {
        super.setCorePoolSize(corePoolSize);
        commandThreadpool.setCorePoolSize(corePoolSize);
    }

    @Override
    public void setThreadFactory(ThreadFactory threadFactory) {
        super.setThreadFactory(threadFactory);
        commandThreadpool.setThreadFactory(threadFactory);
    }

    @Override
    public void setMaximumPoolSize(int maximumPoolSize) {
        super.setMaximumPoolSize(maximumPoolSize);
        commandThreadpool.setMaximumPoolSize(maximumPoolSize);
    }

    @Override
    public void setKeepAliveTime(long time, TimeUnit unit) {
        super.setKeepAliveTime(time, unit);
        commandThreadpool.setKeepAliveTime(time, unit);
    }

    @Override
    public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
        super.setRejectedExecutionHandler(handler);
        commandThreadpool.setRejectedExecutionHandler(handler);
    }

    @Override
    public List<Runnable> shutdownNow() {
        List<Runnable> taskList = super.shutdownNow();
        taskList.addAll(commandThreadpool.shutdownNow());
        return taskList;
    }

    @Override
    public void shutdown() {
        super.shutdown();
        commandThreadpool.shutdown();
    }
}

Le décorateur ci-dessus peut être utilisé comme ci-dessous:

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {

    public static void main(String[] args){

        long timeout = 2000;

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 10, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<>(true));

        threadPool = new TimeoutThreadPoolDecorator( threadPool ,
                timeout,
                TimeUnit.MILLISECONDS);


        threadPool.execute(command(1000));
        threadPool.execute(command(1500));
        threadPool.execute(command(2100));
        threadPool.execute(command(2001));

        while(threadPool.getActiveCount()>0);
        threadPool.shutdown();


    }

    private static Runnable command(int i) {

        return () -> {
            System.out.println("Running Thread:"+Thread.currentThread().getName());
            System.out.println("Starting command with sleep:"+i);
            try {
                Thread.sleep(i);
            } catch (InterruptedException e) {
                System.out.println("Thread "+Thread.currentThread().getName()+" with sleep of "+i+" is Interrupted!!!");
                return;
            }
            System.out.println("Completing Thread "+Thread.currentThread().getName()+" after sleep of "+i);
        };

    }
}