Wie führe ich einen Runnable-Thread in Android in definierten Intervallen aus?

Ich habe eine Anwendung entwickelt, mit der Text in definierten Intervallen auf dem Android-Emulatorbildschirm angezeigt werden kann. Ich benutze die HandlerKlasse. Hier ist ein Ausschnitt aus meinem Code:

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

Wenn ich diese Anwendung ausführe, wird der Text nur einmal angezeigt. Warum?

Die einfache Lösung für Ihr Beispiel lautet:

handler = new Handler();

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

handler.postDelayed(r, 1000);

Oder wir können zum Beispiel einen normalen Thread verwenden (mit dem ursprünglichen Runner):

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

thread.start();

Sie können Ihr ausführbares Objekt nur als Befehl betrachten, der zur Ausführung an die Nachrichtenwarteschlange gesendet werden kann, und den Handler nur als Hilfsobjekt, das zum Senden dieses Befehls verwendet wird.

Weitere Details finden Sie hier http://developer.android.com/reference/android/os/Handler.html

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

Ich denke, kann erste Lösung von Alex2k8 für Update jede Sekunde richtig verbessern

1. Originalcode:

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

2. Analyse

• Nehmen Sie bei den oben genannten Kosten an, dass die tv.append("Hello Word")Kosten T Millisekunden betragen, nachdem die 500- fach verzögerte Anzeigezeit 500 * T Millisekunden beträgt
• Es wird sich verzögert erhöhen, wenn es lange läuft

3. Lösung

Um dies zu vermeiden, ändern Sie einfach die Reihenfolge von postDelayed (), um Verzögerungen zu vermeiden:

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

Zum Wiederholen von Aufgaben können Sie verwenden

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

nenne es wie

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

            }
        },500,1000);

Der obige Code wird zum ersten Mal nach einer halben Sekunde (500) ausgeführt und wiederholt sich nach jeder Sekunde (1000).

Wo

Aufgabe ist die auszuführende Methode

nach der Zeit bis zur ersten Ausführung

( Intervall die Zeit für die Wiederholung der Ausführung)

Zweitens

Sie können CountDownTimer auch verwenden, wenn Sie eine Aufgabe mehrmals ausführen möchten.

    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

Und Sie können es auch mit runnable tun. Erstellen Sie eine ausführbare Methode wie

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

        }
    };

Und nenne es auf beide Arten

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

ODER

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

Ich halte es für diesen typischen Fall für Timerangemessener, etwas mit einem festen Intervall auszuführen . Hier ist ein einfaches Beispiel:

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

Die Verwendung Timerhat nur wenige Vorteile:

• Die anfängliche Verzögerung und das Intervall können einfach in den scheduleFunktionsargumenten angegeben werden
• Der Timer kann durch einfaches Aufrufen gestoppt werden myTimer.cancel()
• Wenn nur ein Thread ausgeführt werden soll, denken Sie daran, myTimer.cancel() vor dem Planen eines neuen Threads aufzurufen (wenn myTimer nicht null ist).

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

Wenn ich die Dokumentation der Handler.post () -Methode richtig verstehe:

Bewirkt, dass Runnable r zur Nachrichtenwarteschlange hinzugefügt wird. Die ausführbare Datei wird auf dem Thread ausgeführt, an den dieser Handler angehängt ist.

Die von @ alex2k8 bereitgestellten Beispiele sind also nicht dieselben, obwohl sie ordnungsgemäß funktionieren. Falls Handler.post()verwendet, werden keine neuen Threads erstellt . Sie posten einfach Runnablein den Thread Handler, der von EDT ausgeführt werden soll . Danach wird EDT nur noch ausgeführt Runnable.run(), sonst nichts.

Denken Sie daran : 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);
}

Ein interessantes Beispiel ist, dass Sie kontinuierlich einen Zähler / eine Stoppuhr in einem separaten Thread sehen können. Zeigt auch GPS-Standort an. Während der Hauptaktivität ist der Benutzeroberflächenthread bereits vorhanden.

Auszug:

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();
}

Um den Code anzusehen, siehe hier:

Thread-Beispiel zur Anzeige des GPS-Standorts und der aktuellen Uhrzeit, die neben dem Benutzeroberflächenthread der Hauptaktivität ausgeführt werden können

Jetzt können Sie in Kotlin Threads folgendermaßen ausführen:

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 mit Coroutinen

In Kotlin können Sie mit Coroutinen Folgendes tun:

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

Probieren Sie es hier aus !