Comment exécuter un thread Runnable dans Android à des intervalles définis?

J'ai développé une application pour afficher du texte à des intervalles définis dans l'écran de l'émulateur Android. J'utilise la Handlerclasse. Voici un extrait de mon code:

handler = new Handler();
Runnable r = new Runnable() {
    public void run() {
        tv.append("Hello World");               
    }
};
handler.postDelayed(r, 1000);

Lorsque j'exécute cette application, le texte ne s'affiche qu'une seule fois. Pourquoi?

La solution simple à votre exemple est:

handler = new Handler();

final Runnable r = new Runnable() {
    public void run() {
        tv.append("Hello World");
        handler.postDelayed(this, 1000);
    }
};

handler.postDelayed(r, 1000);

Ou nous pouvons utiliser un fil normal par exemple (avec le Runner d'origine):

Thread thread = new Thread() {
    @Override
    public void run() {
        try {
            while(true) {
                sleep(1000);
                handler.post(this);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};

thread.start();

Vous pouvez considérer votre objet exécutable comme une commande qui peut être envoyée à la file d'attente de messages pour exécution et le gestionnaire comme un simple objet d'aide utilisé pour envoyer cette commande.

Plus de détails sont ici http://developer.android.com/reference/android/os/Handler.html

new Handler().postDelayed(new Runnable() {
    public void run() {
        // do something...              
    }
}, 100);

Je pense que peut améliorer la première solution d'Alex2k8 pour une mise à jour correcte chaque seconde

1. code d'origine:

public void run() {
    tv.append("Hello World");
    handler.postDelayed(this, 1000);
}

2. analyse

• Dans le coût ci-dessus, supposez le tv.append("Hello Word")coût T millisecondes, après l'affichage, 500 fois le temps différé est de 500 * T millisecondes
• Il augmentera retardé lors d'une exécution de longue durée

3. Solution

Pour éviter cela, il suffit de changer l'ordre de postDelayed (), pour éviter les retards:

public void run() {
    handler.postDelayed(this, 1000);
    tv.append("Hello World");
}

Pour répéter la tâche, vous pouvez utiliser

new Timer().scheduleAtFixedRate(task, runAfterADelayForFirstTime, repeaingTimeInterval);

appelle ça comme

new Timer().scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {

            }
        },500,1000);

Le code ci-dessus s'exécutera la première fois après une demi-seconde (500) et se répétera après chaque seconde (1000)

Où

tâche étant la méthode à exécuter

après le temps de l'exécution initiale

( intervalle de temps pour répéter l'exécution)

Deuxièmement

Et vous pouvez également utiliser CountDownTimer si vous souhaitez exécuter un nombre de tâches plusieurs fois.

    new CountDownTimer(40000, 1000) { //40000 milli seconds is total time, 1000 milli seconds is time interval

     public void onTick(long millisUntilFinished) {
      }
      public void onFinish() {
     }
    }.start();

//Above codes run 40 times after each second

Et vous pouvez également le faire avec runnable. créer une méthode exécutable comme

Runnable runnable = new Runnable()
    {
        @Override
        public void run()
        {

        }
    };

Et appelez-le de ces deux façons

new Handler().postDelayed(runnable, 500 );//where 500 is delayMillis  // to work on mainThread

OU

new Thread(runnable).start();//to work in Background 

Je crois que pour ce cas typique, c'est-à-dire pour exécuter quelque chose avec un intervalle fixe, Timerest plus approprié. Voici un exemple simple:

myTimer = new Timer();
myTimer.schedule(new TimerTask() {          
@Override
public void run() {
    // If you want to modify a view in your Activity
    MyActivity.this.runOnUiThread(new Runnable()
        public void run(){
            tv.append("Hello World");
        });
    }
}, 1000, 1000); // initial delay 1 second, interval 1 second

L'utilisation Timerprésente peu d'avantages:

• Le délai initial et l'intervalle peuvent être facilement spécifiés dans les schedulearguments de la fonction
• Le chronomètre peut être arrêté en appelant simplement myTimer.cancel()
• Si vous souhaitez avoir un seul thread en cours d'exécution, n'oubliez pas d'appeler myTimer.cancel() avant d'en planifier un nouveau (si myTimer n'est pas nul)

Handler handler=new Handler();
Runnable r = new Runnable(){
    public void run() {
        tv.append("Hello World");                       
        handler.postDelayed(r, 1000);
    }
}; 
handler.post(r);

Si je comprends bien la documentation de la méthode Handler.post ():

Provoque l'ajout de Runnable r à la file d'attente de messages. L'exécutable sera exécuté sur le thread auquel ce gestionnaire est attaché.

Donc, les exemples fournis par @ alex2k8, même s'ils fonctionnent correctement, ne sont pas les mêmes. Dans le cas, où Handler.post()est utilisé, aucun nouveau thread n'est créé . Vous venez de publier Runnablesur le fil avec Handlerpour être exécuté par EDT . Après cela, EDT n'exécute que Runnable.run()rien d'autre.

Rappelez - vous: Runnable != Thread.

Kotlin

private lateinit var runnable: Runnable
override fun onCreate(savedInstanceState: Bundle?) {
    val handler = Handler()
    runnable = Runnable {
        // do your work
        handler.postDelayed(runnable, 2000)
    }
    handler.postDelayed(runnable, 2000)
}

Java

Runnable runnable;
Handler handler;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    handler = new Handler();
    runnable = new Runnable() {
        @Override
        public void run() {
            // do your work
            handler.postDelayed(this, 1000);
        }
    };
    handler.postDelayed(runnable, 1000);
}

Un exemple intéressant est que vous pouvez voir en continu un compteur / chronomètre fonctionnant dans un thread séparé. Affiche également la position GPS. Alors que l'activité principale Thread d'interface utilisateur est déjà là.

Extrait:

try {    
    cnt++; scnt++;
    now=System.currentTimeMillis();
    r=rand.nextInt(6); r++;    
    loc=lm.getLastKnownLocation(best);    

    if(loc!=null) { 
        lat=loc.getLatitude();
        lng=loc.getLongitude(); 
    }    

    Thread.sleep(100); 
    handler.sendMessage(handler.obtainMessage());
} catch (InterruptedException e) {   
    Toast.makeText(this, "Error="+e.toString(), Toast.LENGTH_LONG).show();
}

Pour voir le code, voir ici:

Exemple de thread affichant la position GPS et l'heure courante avec le thread d'interface utilisateur de l'activité principale

maintenant dans Kotlin, vous pouvez exécuter des threads de cette façon:

class SimpleRunnable: Runnable {
    public override fun run() {
        println("${Thread.currentThread()} has run.")
    }
}
fun main(args: Array<String>) {
    val thread = SimpleThread()
    thread.start() // Will output: Thread[Thread-0,5,main] has run.
    val runnable = SimpleRunnable()
    val thread1 = Thread(runnable)
    thread1.start() // Will output: Thread[Thread-1,5,main] has run
}

Kotlin avec Coroutines

Dans Kotlin, en utilisant des coroutines, vous pouvez effectuer les opérations suivantes:

CoroutineScope(Dispatchers.Main).launch { // Main, because UI is changed
    ticker(delayMillis = 1000, initialDelayMillis = 1000).consumeEach {
        tv.append("Hello World")
    }
}

Essayez-le ici !