studio - Conceptos básicos de Android: ejecutar código en el hilo de la interfaz de usuario

vista diseño android studio

Question

En el punto de vista de ejecutar código en el subproceso de la interfaz de usuario, ¿hay alguna diferencia entre:

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

o

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

y

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

Answer 1

A partir de Android P puede usar getMainExecutor() :

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

De la documentación del desarrollador de Android :

Devuelva un Ejecutor que ejecutará tareas en cola en el subproceso principal asociado con este contexto. Este es el hilo utilizado para enviar llamadas a los componentes de la aplicación (actividades, servicios, etc.).

Desde el CommonsBlog :

Puede llamar a getMainExecutor () en Context para obtener un Ejecutor que ejecutará sus trabajos en el hilo principal de la aplicación. Hay otras formas de lograr esto, utilizando Looper y una implementación personalizada de Executor, pero esto es más simple.

Answer 2

Hay una cuarta forma de usar Handler

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

Answer 3

Hola chicos, esta es una pregunta básica, lejos, lo digo

usar Handler

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

Answer 4

La respuesta de Pomber es aceptable, sin embargo, no soy un gran fan de crear objetos nuevos repetidamente. Las mejores soluciones son siempre las que intentan mitigar la memoria. Sí, hay recolección automática de basura, pero la conservación de la memoria en un dispositivo móvil cae dentro de los límites de las mejores prácticas. El siguiente código actualiza un TextView en un servicio.

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

}

Se puede utilizar desde cualquier lugar como este:

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

Answer 5

Me gusta el comentario de HPP , se puede usar en cualquier lugar sin ningún parámetro:

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

Answer 6

Ninguno de esos es exactamente el mismo, aunque todos tendrán el mismo efecto neto.

La diferencia entre el primero y el segundo es que si se encuentra en el subproceso principal de la aplicación al ejecutar el código, el primero ( runOnUiThread() ) ejecutará el Runnable inmediatamente. El segundo ( post() ) siempre pone el Runnable al final de la cola de eventos, incluso si ya está en el hilo principal de la aplicación.

El tercero, suponiendo que cree y ejecute una instancia de BackgroundTask , perderá mucho tiempo extrayendo un subproceso de la agrupación de subprocesos, para ejecutar un doInBackground() no doInBackground() predeterminado, antes de hacer lo que equivale a una post() . Este es, con mucho, el menos eficiente de los tres. Use AsyncTask si realmente tiene trabajo que hacer en un hilo de fondo, no solo para el uso de onPostExecute() .

Answer 7

Si necesita usar en Fragmento debe usar

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

en lugar de

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

Porque habrá una excepción de puntero nulo en alguna situación como el fragmento de paginador