Creación y lanzamiento de nuevos hilos (threads)

"¡Hola, amigo! Ellie te habló de los hilos y te diré cómo trabajar con ellos. Para crear un nuevo hilo, necesitas:"

1)  Crear un objeto Hilo

2) Pásalo el método que quieres ejecutar

3)  Llame al método de inicio en el objeto Thread creado.

Considere este ejemplo:

class Printer implements Runnable
{
public void run()
{
System.out.println("I’m printer");
}
}

public static void main(String[] args)
{
Printer printer = new Printer();
Thread childThread = new Thread(printer);
childThread.start();
}

Los pequeños programas de Java generalmente consisten en un hilo llamado «hilo principal». Pero los programas lanzan más a menudo subprocesos adicionales, que se denominan «subprocesos secundarios». El subproceso principal ejecuta el método principal y finaliza. El método de ejecución de Runnable es el método análogo para subprocesos secundarios.

"Ah, muchos hilos significan muchos métodos principales".

Para decirle a un objeto Thread qué método específico debe iniciar, necesitamos pasarle un método de alguna manera. En Java, esto se hace usando la interfaz Runnable . Esta interfaz contiene un solo método abstracto: void run() . La clase Thread tiene un constructor Thread(Runnable Runnable) . Puede pasar cualquier objeto que implemente la interfaz Runnable .

Su clase debe heredar Runnable y anular su método de ejecución . Invocar este método es lo que inicia el nuevo hilo. Puedes escribir lo que quieras en el método de ejecución .

class Printer implements Runnable
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer1 = new Printer("Nick");
Thread thread1 = new Thread(printer1);
thread1.start();

Printer printer2 = new Printer("Jack");
Thread thread2 = new Thread(printer2);
thread2.start();
}

public static void main(String[] args)
{
Printer printer = new Printer("Natasha");

Thread thread1 = new Thread(printer);
thread1.start();

Thread thread2 = new Thread(printer);
thread2.start();

Thread thread3 = new Thread(printer);
thread3.start();
}

Además, puede combinar todo esto en una sola clase. La clase Thread hereda la interfaz Runnable , por lo que solo necesita anular su método de ejecución:

class Printer extends Thread
{
private String name;
public Printer(String name)
{
this.name = name;
}
public void run()
{
System.out.println("I’m " + this.name);
}
}

public static void main(String[] args)
{
Printer printer = new Printer("Jack");
printer.start();

Printer printer2 = new Printer("Jack");
printer2.start();

}

"Esta es una solución más elegante".

"Sí, pero tiene sus defectos:"

1)  Es posible que deba iniciar varios subprocesos basados ​​en un solo objeto, como en el ejemplo con Natasha.

2)  Si hereda de la clase Thread, no puede agregar otra clase principal a su clase.

3)  Si su clase tiene una clase principal, no puede agregar Thread como una segunda clase principal.

"En otras palabras, después de llamar al método de inicio, ¿cada uno de los subprocesos comienza a ejecutar el método de ejecución del objeto pasado al constructor?"

"Sí. Si no se pasa nada al constructor, Thread simplemente ejecuta su método de ejecución interno".

"Pero, ¿por qué no llamamos al método así?"

public static void main(String[] args)
{
 Printer printer1 = new Printer("Nick");
 printer1.run();
}

"Cuando el subproceso principal llega al método de ejecución , su "pequeño robot" simplemente entra y ejecuta todos los comandos dentro de él. Solo después de que se ejecuten, volverá al método principal y continuará ejecutando más comandos. Por lo tanto, no hay segundo " se creará un pequeño robot" . Todo el trabajo se realizará secuencialmente, no en paralelo (simultáneamente)".

"Ya veo. ¿Puedes llamar a algún otro método, algo que no sea correr?"

"No. Todo está vinculado a la interfaz Runnable, que solo "conoce" uno de sus métodos: ejecutar() ".