Les bases d'Android : exécuter du code dans le thread de l'interface utilisateur

Question

Du point de vue de l'exécution du code dans le thread UI, y a-t-il une différence 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");
    }
});

et

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

Answer 1

Aucun de ces éléments n'est exactement le même, mais ils auront tous le même effet net.

La différence entre le premier et le second est que si vous êtes sur le thread principal de l'application lors de l'exécution du code, le premier ( runOnUiThread() ) exécutera le Runnable immédiatement. Le deuxième ( post() ) met toujours le Runnable à la fin de la file d'attente des événements, même si vous êtes déjà sur le thread principal de l'application.

La troisième, en supposant que vous créez et exécutez une instance de BackgroundTask perdra beaucoup de temps à extraire un thread du pool de threads, pour exécuter un no-op par défaut. doInBackground() avant de faire ce qui revient à un post() . C'est de loin la moins efficace des trois. Utilisez AsyncTask si vous avez réellement du travail à faire dans un fil d'arrière-plan, et pas seulement pour l'utilisation de onPostExecute() .

Answer 2

J'aime celui de Commentaire du HPP il peut être utilisé partout sans aucun paramètre :

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

Answer 3

Il existe une quatrième façon d'utiliser Handler

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

Answer 4

La réponse de Pomber est acceptable, mais je ne suis pas un grand fan de la création répétée de nouveaux objets. Les meilleures solutions sont toujours celles qui tentent d'atténuer les problèmes de mémoire. Oui, il y a le garbage collection automatique, mais la conservation de la mémoire dans un appareil mobile relève des meilleures pratiques. Le code ci-dessous met à jour un TextView dans un service.

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

}

Il peut être utilisé de n'importe où comme ceci :

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

Answer 5

Depuis Android P, vous pouvez utiliser getMainExecutor() :

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

De la [Documents pour les développeurs Android](https://developer.android.com/reference/android/content/Context.html#getMainExecutor()) :

Renvoie un exécuteur qui exécutera les tâches en file d'attente sur le thread principal associé à ce contexte. Il s'agit du thread utilisé pour distribuer les appels aux composants de l'application (activités, services, etc.).

De la CommonsBlog :

Vous pouvez appeler getMainExecutor() sur Context pour obtenir un exécuteur qui exécutera ses tâches sur le thread principal de l'application. Il existe d'autres moyens d'accomplir cette tâche, en utilisant Looper et une implémentation personnalisée de l'exécuteur, mais cette méthode est plus simple.