Come eseguire un thread eseguibile in Android a intervalli definiti?

Ho sviluppato un'applicazione per visualizzare del testo a intervalli definiti nella schermata dell'emulatore Android. Sto usando la Handlerclasse. Ecco uno snippet dal mio codice:

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

Quando eseguo questa applicazione, il testo viene visualizzato solo una volta. Perché?

La semplice soluzione per il tuo esempio è:

handler = new Handler();

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

handler.postDelayed(r, 1000);

Oppure possiamo usare il thread normale per esempio (con Runner originale):

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

thread.start();

È possibile considerare l'oggetto eseguibile proprio come un comando che può essere inviato alla coda dei messaggi per l'esecuzione e il gestore come solo un oggetto helper utilizzato per inviare quel comando.

Maggiori dettagli qui http://developer.android.com/reference/android/os/Handler.html

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

Penso che possa migliorare la prima soluzione di Alex2k8 per l'aggiornamento corretto ogni secondo

1. codice originale:

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

2.Analysis

• Nel suddetto costo, si supponga che il tv.append("Hello Word")costo sia T millisecondi, dopo che il tempo di visualizzazione 500 volte ritardato è di 500 * T millisecondi
• Aumenterà in ritardo se eseguito a lungo

3. Soluzione

Per evitare ciò, basta cambiare l'ordine di postDelayed (), per evitare ritardi:

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

Per attività ripetitive è possibile utilizzare

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

chiamalo come

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

            }
        },500,1000);

Il codice sopra verrà eseguito la prima volta dopo mezzo secondo (500) e si ripeterà dopo ogni secondo (1000)

Dove

l'attività è il metodo da eseguire

dopo il tempo di esecuzione iniziale

( intervallo il tempo per ripetere l'esecuzione)

in secondo luogo

E puoi anche usare CountDownTimer se vuoi eseguire un'attività diverse volte.

    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

E puoi anche farlo con runnable. creare un metodo eseguibile come

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

        }
    };

E chiamalo in entrambi questi modi

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

O

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

Credo che per questo caso tipico, vale a dire eseguire qualcosa con un intervallo fisso, Timersia più appropriato. Qui c'è un semplice esempio:

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'uso Timerpresenta alcuni vantaggi:

• Il ritardo iniziale e l'intervallo possono essere facilmente specificati negli scheduleargomenti della funzione
• Il timer può essere fermato semplicemente chiamando myTimer.cancel()
• Se vuoi avere solo un thread in esecuzione, ricorda di chiamare myTimer.cancel() prima di programmarne uno nuovo (se myTimer non è null)

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

Se capisco correttamente la documentazione del metodo Handler.post ():

Fa sì che Runnable r venga aggiunto alla coda dei messaggi. Il runnable verrà eseguito sul thread a cui è collegato questo gestore.

Quindi gli esempi forniti da @ alex2k8, anche se funzionano correttamente, non sono gli stessi. Nel caso in cui Handler.post()venga utilizzato, non vengono creati nuovi thread . È sufficiente pubblicare Runnablesul thread che Handlerdeve essere eseguito da EDT . Successivamente, EDT esegue solo Runnable.run(), nient'altro.

Ricorda: 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)
}

Giava

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 esempio interessante è che puoi vedere continuamente un contatore / cronometro in esecuzione in thread separato. Mostra anche la posizione GPS. Mentre l'attività principale Discussione interfaccia utente è già lì.

Estratto:

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

Per vedere il codice vedi qui:

Esempio di thread che mostra la posizione GPS e l'ora corrente eseguibili insieme al thread dell'interfaccia utente dell'attività principale

ora in Kotlin puoi eseguire discussioni in questo modo:

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 con Coroutine

In Kotlin, usando le coroutine puoi fare quanto segue:

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

Provalo qui !