Pause/arrêt et démarrage/reprise de Java TimerTask en continu?

De TimerTask.annuler():

Noter que l'appel de cette méthode de
dans la méthode run de répétition
minuterie tâche absolument garantit que
la minuterie de la tâche ne sera pas exécutée à nouveau.

Donc, une fois annulée, elle ne sera jamais fonctionner à nouveau. Vous seriez mieux au lieu d'utiliser la plus moderne ScheduledExecutorService (à partir de Java 5+).

Edit: Le concept de base est:

ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
exec.scheduleAtFixedRate(runnable, 0, 1000, TimeUnit.MILLISECONDS);

mais la recherche en elle il n'y a aucun moyen d'annuler cette tâche une fois sa main sans la fermeture du service, qui est un peu bizarre.

TimerTask pourrait être plus facile dans ce cas, mais vous aurez besoin de créer une nouvelle instance lorsque vous démarrez un. Il ne peut pas être réutilisée.

Sinon, vous pouvez encapsuler chaque tâche séparément transitoire de service:

final ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
Runnable task1 = new Runnable() {
  public void run() {
    a++;
    if (a == 3) {
      exec.shutdown();
      exec = Executors.newSingleThreadScheduledExecutor();
      exec.scheduleAtFixedRate(task2, 0, 1000, TimeUnit.MILLISECONDS)
    }
  }
};
exec.scheduleAtFixedRate(task1, 0, 1000, TimeUnit.MILLISECONDS);

Si vous avez déjà annulé une minuterie, vous ne pouvez pas re-démarrer, vous devrez en créer un nouveau.

Voir ce réponse, il contient une vidéo et le code source comment j'ai fait quelque chose de similaire.

Fondamentalement, il existe deux méthode: pause et resume

En pause:

public void pause() {
    this.timer.cancel();
}

En résumé:

public void resume() {
    this.timer = new Timer();
    this.timer.schedule( aTask, 0, 1000 );
}

Qui rend la perception de la mettre en pause/reprendre.

Si votre minuteries d'effectuer différentes actions en fonction de l'état de l'application vous pouvez envisager d'utiliser le StatePattern

Poing définir un résumé de l'état:

abstract class TaskState  {
    public void run();
    public TaskState next();
}

Et autant de membres que vous le souhaitez. La clé est qu'un état amène à un autre.

class InitialState extends TaskState {
    public void run() {
        System.out.println( "starting...");
    }
    public TaskState next() {
         return new FinalState();
    }
 }
 class FinalState extends TaskState  {
     public void run() {
         System.out.println("Finishing...");
     }
     public TaskState next(){
         return new InitialState();
    }
 }

Et que vous modifiez l'état de votre minuterie.

Timer timer = new Timer();
TaskState state = new InitialState();

timer.schedule( new TimerTask() {
     public void run() {
          this.state.run();
          if( shouldChangeState() ) {
              this.state = this.state.next();
           }
     }
 }, 0, 1000 );

Enfin, si ce que vous avez besoin est d'effectuer la même chose, mais à des taux différents, vous pouvez envisager d'utiliser le TimingFramework. C'est un peu plus complexe, mais vous ne les animations superbes, en permettant à la peinture de certains composants lieu à des taux différents ( au lieu d'être linéaire )

De l'examen de votre code source, voici les changements ( qui assez bien valider ma réponse précédente )

Dans task1:

//Stop timer1 and start timer2
timer1.cancel();
timer2 = new Timer(); //<-- just insert this line
timer2.scheduleAtFixedRate(new Task2(), 0, 1000);

et dans task2:

//Stop timer2 and start timer1
timer2.cancel();
timer1 = new Timer(); //<-- just insert this other
timer1.scheduleAtFixedRate(new Task1(), 0, 1000);

Il fonctionne sur ma machine:

Je suis en mesure d'arrêter une minuterie et d'une tâche à l'aide de code suivant:

    if(null != timer)
    {

        timer.cancel();
        Log.i(LOG_TAG,"Number of cancelled tasks purged: " + timer.purge());
        timer = null;
    }

    if(task != null)
    {
        Log.i(LOG_TAG,"Tracking cancellation status: " + task.cancel());
        task = null;
    }