Noções básicas do Android: executando código no thread da interface do usuário

No ponto de vista da execução de código no thread da interface do usuário, existe alguma diferença entre:

MainActivity.this.runOnUiThread(new Runnable() {
    public void run() {
        Log.d("UI thread", "I am the UI thread");
    }
});

ou

MainActivity.this.myView.post(new Runnable() {
    public void run() {
        Log.d("UI thread", "I am the UI thread");
    }
});

e

private class BackgroundTask extends AsyncTask<String, Void, Bitmap> {
    protected void onPostExecute(Bitmap result) {
        Log.d("UI thread", "I am the UI thread");
    }
}

Nenhum deles é exatamente o mesmo, embora todos tenham o mesmo efeito líquido.

A diferença entre o primeiro e o segundo é que, se você estiver no encadeamento principal do aplicativo ao executar o código, o primeiro ( runOnUiThread()) executará o Runnableimediatamente. O segundo ( post()) sempre coloca o Runnablefinal da fila de eventos, mesmo se você já estiver no encadeamento principal do aplicativo.

O terceiro, supondo que você crie e execute uma instância de BackgroundTask, perderá muito tempo capturando um encadeamento do conjunto de encadeamentos, para executar um no-op padrão doInBackground(), antes de, eventualmente, fazer o que equivale a a post(). Este é de longe o menos eficiente dos três. Use AsyncTaskse você realmente tiver trabalho a fazer em um encadeamento em segundo plano, não apenas pelo uso de onPostExecute().

Eu gosto do comentário do HPP , ele pode ser usado em qualquer lugar sem nenhum parâmetro:

new Handler(Looper.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
        Log.d("UI thread", "I am the UI thread");
    }
});

Existe uma quarta maneira de usar Handler

new Handler().post(new Runnable() {
    @Override
    public void run() {
        // Code here will run in UI thread
    }
});

A resposta de Pomber é aceitável, no entanto, não sou muito fã de criar novos objetos repetidamente. As melhores soluções são sempre as que tentam atenuar a memória. Sim, existe uma coleta automática de lixo, mas a conservação da memória em um dispositivo móvel está dentro dos limites das melhores práticas. O código abaixo atualiza um TextView em um serviço.

TextViewUpdater textViewUpdater = new TextViewUpdater();
Handler textViewUpdaterHandler = new Handler(Looper.getMainLooper());
private class TextViewUpdater implements Runnable{
    private String txt;
    @Override
    public void run() {
        searchResultTextView.setText(txt);
    }
    public void setText(String txt){
        this.txt = txt;
    }

}

Pode ser usado em qualquer lugar como este:

textViewUpdater.setText("Hello");
        textViewUpdaterHandler.post(textViewUpdater);

No Android P, você pode usar getMainExecutor():

getMainExecutor().execute(new Runnable() {
  @Override public void run() {
    // Code will run on the main thread
  }
});

Dos documentos do desenvolvedor do Android :

Retorne um Executor que executará tarefas enfileiradas no thread principal associado a este contexto. Esse é o encadeamento usado para despachar chamadas para componentes de aplicativos (atividades, serviços, etc.).

Do CommonsBlog :

Você pode chamar getMainExecutor () no Contexto para obter um Executor que executará suas tarefas no encadeamento principal do aplicativo. Existem outras maneiras de fazer isso, usando Looper e uma implementação executora personalizada, mas isso é mais simples.

Se você precisar usar o Fragment, use

private Context context;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        this.context = context;
    }


    ((MainActivity)context).runOnUiThread(new Runnable() {
        public void run() {
            Log.d("UI thread", "I am the UI thread");
        }
    });

ao invés de

getActivity().runOnUiThread(new Runnable() {
    public void run() {
        Log.d("UI thread", "I am the UI thread");
    }
});

Porque haverá uma exceção de ponteiro nulo em algumas situações, como fragmento de pager

oi pessoal, essa é uma pergunta básica, qualquer coisa que eu digo

use Handler

new Handler().post(new Runnable() {
    @Override
    public void run() {
        // Code here will run in UI thread
    }
});