Como executar um thread Runnable no Android em intervalos definidos?

Desenvolvi um aplicativo para exibir algum texto em intervalos definidos na tela do emulador do Android. Eu estou usando a Handlerclasse. Aqui está um trecho do meu código:

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

Quando executo esse aplicativo, o texto é exibido apenas uma vez. Por quê?

A correção simples para o seu exemplo é:

handler = new Handler();

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

handler.postDelayed(r, 1000);

Ou podemos usar thread normal, por exemplo (com o Runner original):

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

thread.start();

Você pode considerar seu objeto executável apenas como um comando que pode ser enviado para a fila de mensagens para execução e o manipulador como apenas um objeto auxiliar usado para enviar esse comando.

Mais detalhes estão aqui http://developer.android.com/reference/android/os/Handler.html

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

Eu acho que pode melhorar a primeira solução do Alex2k8 para atualização correta a cada segundo

1. código original:

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

2.Análise

• No custo acima, assuma o tv.append("Hello Word")custo T milissegundos, depois que o tempo de exibição 500 vezes atrasado é 500 * T milissegundos
• Aumentará atrasado quando executado muito tempo

3. Solução

Para evitar isso, basta alterar a ordem de postDelayed (), para evitar atrasos:

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

Para repetir tarefas, você pode usar

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

chame assim

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

            }
        },500,1000);

O código acima será executado pela primeira vez após meio segundo (500) e se repetirá após cada segundo (1000)

Onde

tarefa sendo o método a ser executado

após o tempo de execução inicial

( intervalo do tempo para repetir a execução)

Em segundo lugar

E você também pode usar CountDownTimer se desejar executar um número de tarefas várias vezes.

    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 você também pode fazê-lo com executável. crie um método executável como

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

        }
    };

E chamá-lo de ambas as maneiras

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

OU

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

Eu acredito que neste caso típico, ou seja, executar algo com um intervalo fixo, Timeré mais apropriado. Aqui está um exemplo simples:

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

O uso Timertem poucas vantagens:

• O atraso inicial e o intervalo podem ser facilmente especificados nos scheduleargumentos da função
• O temporizador pode ser parado simplesmente chamando myTimer.cancel()
• Se você deseja ter apenas um thread em execução, lembre-se de ligar myTimer.cancel() antes de agendar um novo (se myTimer não for nulo)

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

Se eu entendi corretamente a documentação do método Handler.post ():

Faz com que o Runnable r seja adicionado à fila de mensagens. O executável será executado no encadeamento ao qual esse manipulador está anexado.

Portanto, os exemplos fornecidos pelo @ alex2k8, mesmo que estejam funcionando corretamente, não são os mesmos. Caso Handler.post()seja usado, nenhum novo encadeamento será criado . Você acabou de postar Runnableno thread Handlerpara ser executado pelo EDT . Depois disso, o EDT apenas executa Runnable.run(), nada mais.

Lembre-se: 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);
}

Um exemplo interessante é que você pode ver continuamente um contador / cronômetro em execução em thread separado. Também mostrando a localização do GPS. Enquanto a atividade principal, o thread da interface do usuário já estiver lá.

Excerto:

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

Para ver o código, veja aqui:

Exemplo de encadeamento que exibe a localização do GPS e a hora atual executáveis ​​junto com o encadeamento da interface do usuário da atividade principal

agora no Kotlin você pode executar threads desta maneira:

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 com corotinas

No Kotlin, usando corotinas, você pode fazer o seguinte:

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

Experimente aqui !