Comment en attente d'un thread

En effet plutôt l'utilisation d' ExecutorService au lieu 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!";
    }
}

Jouer un peu avec les timeout argument en Futur#get() méthode, par exemple une augmentation à 5 et vous verrez que le thread se termine. Vous pouvez intercepter le délai d'attente dans l' catch (TimeoutException e) bloc.

Mise à jour: de clarifier conceptuel de l'incompréhension, de l' sleep() est pas nécessaire. Il est seulement utilisé pour le SSCCE/à des fins de démonstration. Il suffit de ne votre long de la tâche en cours d'exécution dans le lieu de sleep(). À l'intérieur de votre longue tâche en cours d'exécution, vous devriez vérifier si le fil n'est pas interrompu comme suit:

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

Envisager d'utiliser une instance de ExecutorService. Les deux invokeAll() et invokeAny() méthodes sont disponibles avec un timeout paramètre.

Le thread se bloque jusqu'à ce que la méthode est terminée (pas sûr si cela est souhaitable), soit parce que la tâche(s) terminé normalement ou que le délai a été atteint. Vous pouvez inspecter le retour de l' Future(s) pour déterminer ce qui s'est passé.

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

De la Java la documentation mentionnés ci-dessus:

Que si un fil ne répond pas à enfiler.interrompre?

Dans certains cas, vous pouvez utiliser l'application astuces spécifiques. Par exemple,
si un thread est en attente sur un support, vous pouvez fermer la socket
cause le fil de rentrer immédiatement. Malheureusement, il n'y a vraiment
n'est pas une 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 à
Fil de discussion.interruption, il ne serait pas répondre à enfiler.arrêtez soit. Ces
ces cas comprennent délibérée de déni de service attaques, et les opérations d'e/S
pour le thread.arrêt et du fil.l'interruption ne fonctionnent pas correctement.

Ligne Du Bas:

Assurez-vous que tous les threads peut être interrompue, ou autre vous avez besoin de connaissances spécifiques sur le fil - un peu comme un drapeau à définir. Peut-être que vous pouvez exiger que la tâche sera donné avec le code nécessaire pour l'arrêter - définir une interface avec un stop() méthode. Vous pouvez également vous avertir lorsque vous avez échoué à arrêter une tâche.

J'ai créé une classe d'aide juste pour cela, il y a quelques 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;
}
}
}
}

Il est appelé 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) {}  

L'extrait de code suivant va démarrer une opération dans un thread séparé, puis attendre jusqu'à 10 secondes de la fin de l'opération. Si l'opération ne se termine pas dans le temps, le code sera tentative pour annuler l'opération, puis continuer son petit bonhomme de chemin. Même si l'opération ne peut être annulée facilement, le parent thread va pas attendre que l'enfant thread pour résilier.

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 appliquée dans un certain nombre de façons. Si vous n'avez pas d'exigences particulières, vous pouvez simplement appeler Executors.newCachedThreadPool() pour la mise en pool de threads avec pas de limite supérieure sur le nombre de threads.

Voici ma vraiment simple à utiliser classe d'assistance pour exécuter ou appel morceau de code Java 🙂

Ceci est basé sur l'excellent 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;
}
}

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

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

Si la première réponse est oui et le second l'est pas, vous pouvez le garder 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 limiter vos exigences - ou de montrer un peu de code.

Maintenant , l répondre à une question de ce genre. Il arrive à décoder l'image. Le processus de décodage prend trop de temps que l'écran de garder le noir. l'ajout d'un temps de controler: quand le temps est trop long, une fenêtre pop up à partir du Thread courant.
Ce qui suit est la 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);

Dans la solution donnée par la BalusC, le thread principal va rester bloquée pendant la période de délai d'attente. Si vous disposez d'un pool de threads avec plus d'un fil, vous aurez besoin du même nombre de threads supplémentaires qui seront à l'aide de L'avenir.get(délai long,TimeUnit unit) de blocage d'appel d'attendre et de fermer le thread si elle dépasse le délai d'attente.

Une solution générique à ce problème est de créer un ThreadPoolExecutor Décorateur qui peut ajouter le délai d'attente de la fonctionnalité. Ce Décorateur classe devrait créer autant de threads que ThreadPoolExecutor a, et tous ces fils doivent être utilisés qu'à patienter et à proximité de la ThreadPoolExecutor.

La classe générique doit être mis en œuvre 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();
}
}

Ci-dessus décorateur 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);
};
}
}