Android mejor y manera segura de detener el hilo

Usted debe hacer que su hilo de apoyo interrupciones. Básicamente, puede llamar a yourThread.interrupt() para detener el subproceso y, en su método run (), necesitará revisar periódicamente el estado de Thread.interrupted()

Hay un buen tutorial aquí .

Esta situación no es de ninguna manera diferente del estándar de Java. Puede utilizar la forma estándar para detener un subproceso:

 class WorkerThread extends Thread { volatile boolean running = true; public void run() { // Do work... if (!running) return; //Continue doing the work } } 

La idea principal es comprobar el valor del campo de vez en cuando. Cuando necesite detener su subproceso, establezca la running en false. También, como Chris ha señalado, puede utilizar el mecanismo de interrupción.

Por cierto, cuando se utiliza AsyncTask, su apporach no difiere mucho. La única diferencia es que tendrás que llamar al método isCancel() de tu tarea en lugar de tener un campo especial. Si llama cancel(true) , pero no implementa este mecanismo, el hilo no se detendrá por sí mismo, se ejecutará hasta el final.

En Android se aplican las mismas reglas que en un entorno Java normal. En Java los hilos no se matan, pero la detención de un hilo se hace de una manera cooperativa . Se le pide al subproceso que termine y el subproceso puede apagarse con gracia.

A menudo se utiliza un campo volatile boolean que el hilo comprueba y termina periódicamente cuando se ajusta al valor correspondiente.

No utilizaría un boolean para comprobar si el hilo de rosca debe terminar . Si utiliza volatile como un modificador de campo, esto funcionará de forma fiable, pero si su código se vuelve más complejo, para que en su lugar utilice otros métodos de bloqueo dentro del bucle while, podría ocurrir, que su código no terminará en absoluto o al menos tomará más tiempo Como usted puede ser que desee.

Ciertos métodos de biblioteca de bloqueo admiten la interrupción.

Cada subproceso ya tiene un estado interrumpido de bandera booleana y debe utilizarlo. Se puede implementar de esta manera:

 public void run() { try { while(!Thread.currentThread().isInterrupted()) { // ... } } catch (InterruptedException consumed) /* Allow thread to exit */ } } public void cancel() { interrupt(); } 

Código fuente extraído de Java Concurrency in Practice . Dado que el método cancel() es público, puede permitir que otro subproceso invoque este método como desee.

También se interrupted método estático mal nombrado que borra el estado interrumpido del subproceso actual.

El método Thread.stop() que podría utilizarse para detener un subproceso ha quedado obsoleto; Para más información ver; ¿Por qué Thread.stop, Thread.suspend y Thread.resume Deprecated? .

Su mejor apuesta es tener una variable que el hilo mismo consulte, y sale voluntariamente si la variable es igual a un cierto valor. A continuación, manipule la variable dentro de su código cuando desee que el subproceso salga. Alternativamente, por supuesto, puede utilizar un AsyncTask en AsyncTask lugar.

Actualmente y por desgracia no podemos hacer nada para detener el hilo ….

Añadiendo algo a la respuesta de Matt podemos llamar a interrupt() pero eso no detiene thread … Simplemente le dice al sistema que detenga el hilo cuando el sistema quiera matar algunos hilos. El resto es hecho por el sistema, y ​​podemos comprobarlo llamando a interrupted() .

[Ps: Si realmente vas con interrupt() te pediría que hicieras algunos experimentos con un breve descanso después de llamar a interrupt() ]

La cosa es, usted necesita comprobar el hilo está funcionando o no ? Campo:

 private boolean runningThread = false; 

En el hilo:

 new Thread(new Runnable() { @Override public void run() { while (true) { try { Thread.sleep((long) Math.floor(speed)); if (!runningThread) { return; } yourWork(); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); 

Si desea detener el hilo, debe hacer el siguiente campo

 private boolean runningThread = false; 

Dentro de cualquier clase de actividad se crea un método que asignará NULL a instancia de subproceso que se puede utilizar como alternativa al método depreciado stop () para detener la ejecución de subprocesos:

 public class MyActivity extends Activity { private Thread mThread; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); mThread = new Thread(){ @Override public void run(){ // Perform thread commands... for (int i=0; i < 5000; i++) { // do something... } // Call the stopThread() method. stopThread(this); } }; // Start the thread. mThread.start(); } private synchronized void stopThread(Thread theThread) { if (theThread != null) { theThread = null; } } } 

Esto funciona para mí sin ningún problema.