Arrêter un exécutable dans un Thread séparé

Salut j'ai actuellement un problème avec mon application android. Im commencer un thread supplémentaire via
la mise en œuvre de la Excecutor Interface:

class Flasher implements Executor {
    Thread t;
   public void execute(Runnable r) {
     t = new Thread(r){
     };
     t.start();
   }
 }

Je commence mon Exécutables comme ceci:

flasherThread.execute(flashRunnable);

mais comment puis-je l'arrêter?

stackoverflow.com/questions/671049/...
Ne pas mettre en œuvre votre propre Executor sans une très bonne raison de le faire - utiliser ceux déjà disponibles dans l'API Java. En outre: l'Arrêt d'une tâche effectuée dans un autre thread en Java repose toujours sur l'autre fil, ou plutôt de sa tâche à coopérer. Si votre Runnable garde assis dans une boucle sans fin, fondamentalement, ne rien faire, il n'y a "aucun" moyen de l'arrêter.
Il n'y a pas une telle méthode dans le Exécuteur de l'interface.
double possible de Comment arrêter un thread par un autre thread?

OriginalL'auteur TobiasPC | 2012-12-19

  1. 5

    Ok, c'est juste la base de filetage 101, mais qu'il y ait un autre exemple:

    De la vieille école de filetage:

    class MyTask implements Runnable {
    public volatile boolean doTerminate;

    public void run() {
        while ( ! doTerminate ) {
            //do some work, like:
            on();
            Thread.sleep(1000);
            off();
            Thread.sleep(1000);
        }
    }
}

    puis

    MyTask task = new MyTask();

Thread thread = new Thread( task );

thread.start();

//let task run for a while...

task.doTerminate = true;

//wait for task/thread to terminate:
thread.join();
//task and thread finished executing

    Edit:

    Viens de tombé sur ce très instructif L'Article sur la façon d'arrêter les threads.

    Java de manière standard d'interrompre un thread est... pour interrompre le fil. Et dans votre Exécutable, vous pouvez utiliser while(!Thread.currentThread().isInterrupted()) {soSomething();} à arrêter ce que vous faites quand une interruption du signal est envoyé.
    Sans aucun doute. - Cependant, il y a encore aucun moyen de forcer l'arbitraire Runnable (ou thread) à la fin; dans tous en cas de coopération par le Runnable est nécessaire. Et c'est le point de l'OP: Pour être en mesure d'arrêter l'exécution d'un thread, le code dans ce thread doit être explicitement écrit à l'appui.
    Je ne suis pas en discuter au sujet de la coopération bits - juste dire que la coopération est généralement mis en œuvre avec l'interruption mécanisme, plutôt que boolean drapeaux.

    OriginalL'auteur JimmyB

  2. 3

    Pas sûr que la mise en œuvre de Executor est une bonne idée. Je préfère utiliser l'un des exécuteurs Java fournit. Ils vous permettent de contrôler votre Runnable exemple par le biais de Future interface:

    ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<?> future = executorService.submit(flashRunnable);
...
future.cancel(true);

    Aussi assurez-vous de libérer des ressources qui ExecutorService consomme en appelant executorService.shutdown() lorsque votre programme n'a pas besoin du mode d'exécution asynchrone plus.

    "vous permettent de contrôler votre Praticable en instance" - Désolé, mais ce n'est pas vrai. Ils vous permettent de contrôler le Executor, mais le Runnable peut encore faire ce qu'il veut, y compris de ne pas appelé à disparaître et ainsi gâcher l'exécuteur testamentaire et de ce pas.
    future.cancel() méthode peut retourner false, indiquant que votre demande d'annulation a échoué, mais Future contrôle un seul Runnable, par exemple, pas le Executor qui peut exécuter ou de planifier des milliers de tâches
    Alors, comment peut-on influencer le Runnable exemple par le biais de la Future?
    Le Runnable's thread sera "interrompue" - mais qui n'implique pas nécessairement une InterruptedException sera levée, ou qu'il y a de tout autre effet sur la Runnable exemple à tous. Donc, si le Runnable n'est pas explicitement prêt de gérer à l'extérieur de la résiliation condition n'est "non" moyen de l'arrêter.
    Je ne dit pas que c'est garanti. Encore, vous pouvez utiliser Thread.interrupted() appeler pour vérifier si interrupt() a été appelée à la place de l'écriture des tons de vieux-école code

    OriginalL'auteur hoaz

  3. 1

    Au lieu de la mise en œuvre de votre propre Exécuteur testamentaire, vous devriez regarder ExecutorService. ExecutorService a un arrêt de méthode:

    Initie un arrêt dans lequel précédemment présenté les tâches sont exécutées, mais pas de nouvelles tâches seront acceptés.

    OriginalL'auteur tom

  4. 1

    Je vous suggérons d'utiliser le ExecutorService, avec la Furure objet, ce qui vous donne le contrôle sur le fil qui est créé par l'exécuteur testamentaire. Comme l'exemple suivant

    ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(runnabale);
try {
     future.get(2, TimeUnit.SECONDS);
} catch (TimeoutException ex) {
     Log.warn("Time out expired");
} finally {
     if(!future.isDone()&&(!future.isCancelled())) 
        future.cancel(true);

    executor.shutdownNow();
}

    Ce code indique que l'exécutable sera contraint de résilier au bout de 2 secondes. Bien sûr, vous pouvez gérer votre Avenir ojbect que vous le souhaitez et de le terminer selon vos exigences

    OriginalL'auteur pkran