Detener temporizador sin destruir y volver a crear – Android

Tengo este AsyncTask, que duerme 0.1 segundo cada vez que ejecuta "doInBackground", antes de que yo estaba usando un CountDownTimer para controlar mi tiempo.

Mi problema es: Quiero lograr un temporizador que puede pausar sin llamar a .cancel() y cuando se inicia la creación de otro temporizador.

¿Hay una manera de lograr esto es Android? No he encontrado cómo hacerlo de una manera diferente. ¿Puede usted ejemplo?

Donde he encontrado ejemplos cancelando el temporizador:

¿Cómo detener el temporizador en android?
¿Temporizador Android? ¿Cómo?
Http://www.androidhub4you.com/2013/04/countdown-demo-in-android-custom-timer.html

EDITAR

Responder a Kevin Krumwiede: Este proyecto es una especie de juego, que debo golpear bloques en un tiempo determinado, así que quiero lograr una manera de detener el temporizador cuando el jugador utiliza algún tipo de poder especial (presione un botón especificado).

EDIT2

Responder a Kushal: No sé si ha compilado este código, pero no puedo usar la variable task1. Aquí va el código:

  public void doIt(){ final ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor(); final Runnable task = new Runnable() { @Override public void run() { timerAsyncTask.execute(); if(true) { exec.shutdown(); // shutdown this execution //exec = Executors.newSingleThreadScheduledExecutor(); exec.scheduleAtFixedRate(task, 0, 100, TimeUnit.MILLISECONDS); } } }; exec.scheduleAtFixedRate(task, 0, 100, TimeUnit.MILLISECONDS); }

Aquí exec = Executors.newSingleThreadScheduledExecutor(); Me muestra un error:

Error: (33, 21) error: no se puede asignar un valor a la variable final exec

Lo que creo que es bastante bien, una vez que el exec es una variable final.

Y aquí exec.scheduleAtFixedRate(task, 0, 100, TimeUnit.MILLISECONDS); Tengo otro error:

Error: error (34, 46): la tarea variable podría no haber sido inicializada

¿Puedes explicar, cómo puedo usar este pedazo de código? Soy bastante nuevo en Android. Gracias.

Le sugiero que evite Timers en Android por completo. Android tiene una ligera y mejor solución llamada Handler

Puede encontrar una comparación entre estos dos aquí . Para resumir

Comparación Handler VS Timer

Si bien la reprogramación de Handler es muy fácil, no puede reprogramar Timer
En Handler puede adjuntar a cualquier programa Runnable pero Timer para un solo TimerTask
TimerTask es puramente tarea de fondo por lo que no se puede actualizar UserInterface, pero eso no es cierto para Handler's Runnables
El temporizador causa las exculpas
Temporizador tiende a vaciar más memoria comparar a Handler ver el gráfico del objeto se conserva por temporizador y Handler. Aumentará rápidamente para Timer si está creando y programando nueva tarea.

Como sugiere el post, el uso de Handler es bastante simple. Aquí hay un ejemplo de código

 import android.os.Bundle; import android.os.Handler; import android.os.Looper; import android.support.v7.app.AppCompatActivity; public class TestActivity extends AppCompatActivity { private static int INITIAL_TIMER_DELAY = 100; private static int TIMER_PERIOD = 100; private android.os.Handler handler; private Runnable runnable; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); handler = new Handler(Looper.getMainLooper()); runnable = new Runnable() { @Override public void run() { // Do something and reschedule ourself handler.postDelayed(this, TIMER_PERIOD); } }; handler.postDelayed(runnable, INITIAL_TIMER_DELAY); } @Override protected void onDestroy() { super.onDestroy(); cancelTimer(); } private void cancelTimer() { if (handler != null) { handler.removeCallbacks(runnable); } } private void rescheduleRunnable() { handler.postDelayed(runnable, INITIAL_TIMER_DELAY) } }

Puede obtener su requriment usando la clase ScheduledExecutorService

La diferencia básica entre ScheduledExecutorService y la clase Timer es:

Utilizando la clase Timer, no puede comprobar cómo va su ejecución. Puede iniciar y detener la ejecución pero no puede comprobar la ejecución en función de la condición
ScheduledExecutorService proporciona el modo de comprobar cómo se ejecuta la ejecución entre la llamada de inicio y de detención. Si cualquier ejecución de la tarea encuentra una excepción, las ejecuciones posteriores se suprimen

Cómo podemos lograr su requisito:

Necesitamos un retardo de 0,1 segundo entre la ejecución de doInBackground()

Podremos pausar nuestra ejecución cuando comience otra ejecución

 ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor(); Runnable task1 = new Runnable() { public void run() { // start your AsyncTask here new <your_task>().execute(); if (<check_your_condition_when_to_pause>) { exec.shutdown(); // shutdown this execution exec = Executors.newSingleThreadScheduledExecutor(); exec.scheduleAtFixedRate(task1, 0, 100, TimeUnit.MILLISECONDS); // here i have passed task1 for example // here we need to pass next task runnable which // we want to run after 0.1 seconds } else { // continue normal } } }; exec.scheduleAtFixedRate(task1, 0, 100, TimeUnit.MILLISECONDS);

Referencia de crédito: Respuesta 1 y Respuesta 2

Espero que esto ayude a resolver algunas de sus dudas