Bases d'Android: exécuter du code dans le thread d'interface utilisateur

Du point de vue de l'exécution de code dans le thread d'interface utilisateur, 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");
    }
}

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

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

Le 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 finalement faire ce qui équivaut à a post(). C'est de loin le moins efficace des trois. À utiliser AsyncTasksi vous avez réellement du travail à faire dans un fil d'arrière-plan, pas seulement pour l'utilisation de onPostExecute().

J'aime celui du commentaire HPP , il peut être utilisé n'importe où sans aucun paramètre:

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

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

La réponse de Pomber est acceptable, mais je ne suis pas un grand fan de la création de nouveaux objets à plusieurs reprises. Les meilleures solutions sont toujours celles qui tentent d'atténuer le manque de mémoire. Oui, il existe une collecte automatique des déchets, mais la conservation de la mémoire dans un appareil mobile entre dans les limites 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);

Depuis Android P, vous pouvez utiliser getMainExecutor():

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

À partir des documents des développeurs Android :

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

Du CommonsBlog :

Vous pouvez appeler getMainExecutor () sur Context pour obtenir un exécuteur qui exécutera ses travaux sur le thread principal de l'application. Il existe d'autres façons d'accomplir cela, en utilisant Looper et une implémentation d'Executor personnalisée, mais c'est plus simple.

Si vous devez utiliser dans Fragment, vous devez utiliser

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

au lieu de

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

Parce qu'il y aura une exception de pointeur nul dans certaines situations comme un fragment de pager

salut les gars celui-ci est une question de base tout de suite je dis

utiliser le gestionnaire

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