java - termino - runnable android

La mejor forma de crear y usar una clase Runnable anónima

Question

Quiero usar una clase anónima para ejecutable. Hay dos formas, pero no sé si hacen lo mismo o no:

Método uno: usar directamente Runnable y ejecutar llamada

new Runnable() {
    @Override
    public void run() {
    }
}.run();

Método dos: cree un ejecutable anónimo y pegue en Thread, usando el método start en lugar de ejecutar:

new Thread( new Runnable() {
    @Override
    public void run() {
    }
}).start();

Creo que el método dos es muy cierto. Pero, no sé si hace lo mismo que el método uno. ¿Podemos llamar al método run en Runnable directamente?

Gracias :)

Answer 1

Aquí hay un ejemplo de código simple de cómo crear una clase Runnable anónima correctamente y manejar la pérdida de memoria (Ejemplo para Android):

public class MainActivity extends Activity{
@Override
protected void onCreate(Bundle savedInstanceState) {

            MyRunnable myRunnable = new MyRunnable(this);
            myHandler.postDelayed(myRunnable, TimeUnits);
}

// Must be declared as a static class    
private static class MyRunnable implements Runnable {
        WeakReference<MainActivity> mActivity;
        // Creating weakreference
        MyRunnable(MainActivity activity) {
            mActivity = new WeakReference<>(activity);
        }

        @Override
        public void run() {
            MainActivity activity = mActivity.get();
            // Checking reference exist or not
            if (activity != null) {
                    //Do necessary tasks
                }
            }
        }
    }

}

Answer 2

Como @Hovercraft menciona, si llamas directamente a un método Runnable.run() , no se crea un Thread . Es como llamar a cualquier otro método ( System.out.println(...) , ...).

Cuando pasa un objeto Runnable al constructor Thread , eso establece el campo target en el Thread para que sea su objeto:

this.target = target;

Entonces cuando llamas a start() en el Thread , esto hace el trabajo de bifurcar el nuevo hilo y llamar al método Thread.run() . El Thread.run() llama el método run() del objetivo a su vez:

public void run() {
    if (target != null) {
        target.run();
    }
}

Así que pasar el Runnable a un Thread y luego llamar a start() es la forma de ejecutar Runnable en segundo plano en un hilo separado.

Answer 3

Como los otros han mencionado, usar la clase Thread es la forma correcta. Sin embargo, también debe consultar el uso de la estructura de Executors Javas para gestionar los subprocesos en ejecución.

Executors.newSingleThreadExecutor().execute(new Runnable() {
    @Override 
    public void run() {
        // code in here
    }
});

Por supuesto, solo usar Thread directamente está bien. Pero generalmente se recomienda (o prefiere) usar el marco. Deje que Java maneje los detalles finos para usted.

Answer 4

En el método uno solo funcionará como un método como la interfaz Runnable implementándolo y llamándolo, pero no se creará ningún hilo de fondo. El hecho es que cuando llamamos al método de inicio provoca que el subproceso corrosponding comience a ejecutarse, Java Virtual Machine llama internamente al método de ejecución de este subproceso. Entonces, para comenzar un hilo, debemos llamar al método de inicio con la referencia Ejecución ejecutable. En el método uno, incluso no podemos llamar al método de inicio con la referencia de la interfaz ejecutable, ya que la interfaz Runnable no admite el método start (). Por lo tanto, es obligatorio crear el objeto de la clase Thread para iniciar la ejecución de la secuencia.

Answer 5

La primera forma es incorrecta: no crea un nuevo hilo, por lo que es inútil.

Es como poner el código fuera de un ejecutable.

Tenga en cuenta que hay dos maneras de iniciar un nuevo hilo en el código definido en una clase anónima, como se describe en el javadoc de Thread, pero su método 1 no está entre ellos y su método 2 es el que generalmente debería preferir.

Answer 6

Me gustaría agregar algo sobre esta discusión (ya obtuviste buenas respuestas).
Si su objeto Runnable es sin estado, para reducir las asignaciones de memoria (que toman tiempo + consumen algo de memoria, piense en un caso en el que una aplicación usa mucho los subprocesos), considere tener un campo estático que contenga el objeto ejecutable.

private static Runnable runnable = new Runnable() { //Once again - do this only if this is a statelss object!
   public void run() {
   }
} 

//Use the runnable somewhere in the code

Answer 7

No, generalmente no invocará a run() directamente en Runnable ya que no obtendrá ningún fondo de esta manera. Si no quiere y necesita un hilo de fondo, llame directamente a run() , pero si desea crear un hilo de fondo y ejecutar Runnable desde allí, debe crear un Thread nuevo y luego pasar el Runnable. en su constructor, y llame a start() .

Además, hay otras maneras de llevar a cabo esta tarea, incluido el uso de ejecutores y servicios ejecutivos, y debe considerar los usos de este ya que ofrecen más flexibilidad y potencia que el uso de un objeto de hilos desnudo.

También querrá echar un vistazo al uso de la interfaz Future y la clase FutureTasks que son como Runnables, solo le permiten devolver un resultado cuando se completa. Si usaste un SwingWorker, entonces ya has usado una interfaz Future sin darte cuenta.

Answer 8

Recuerde siempre que Runnable es solo un código que desea o puede ejecutar en un subproceso. Una forma de definir el código Runnable de forma anónima es:

  Runnable codeToRunOnThread=new Runnable() {
      @Override
      public void run() {
      //code to run in a thread you want
      }
  };

Y luego puedes crear un hilo y pasar el Runnable que creaste a ese nuevo hilo como este

  Thread myThread=new Thread(codeToRunOnThread);
  myThread.start();

Después de llamar al método start () de la clase Thread, el código que se ejecuta dentro del método run () se ejecuta en el hilo recién creado.

También puede buscar otra forma de crear un objeto Runnable here

Answer 9

Su método 1 generalmente no puede hacer ningún trabajo útil. Con este método, si desea obtener el resultado del programa HelloWorld.java simple, es decir, "Hello World", se parecerá al siguiente código inútil, pero imprime "Hello World". Entonces deberías usar tu Segundo Método. Código inútil:

class MyRunnable implements Runnable {

    public void run() { 
    System.out.println("Hello World");
    }

    public static void main(String[]arg){ 
    MyRunnable myRunnable = new NamedRunnable( );
    namedRunnable.run();
    } 
}

Answer 10

Tu método 1 no tiene sentido. La interfaz Runnable es significativa para enhebrar solo cuando se ejecuta dentro de un Thread (su método 2). Si quieres encontrar otra forma de envolver en línea, un fragmento de código dentro de un hilo, esta podría ser una:

Thread t = new Thread()
{
     public void run()
     {
        // put whatever code you want to run inside the thread here.
     }
};
t.start();