Por favor explique la salida de funcionamiento de rosca() y start() métodos

Question

Por favor, explique la salida del código de abajo:

Si llamo th1.run(), la salida es:

EXTENDS RUN>> 
RUNNABLE RUN>> 

Si llamo th1.start() , la salida es:

RUNNABLE RUN>> 
EXTENDS RUN>> 

¿Por qué esta incoherencia? Por favor explique.

class ThreadExample extends Thread{ 
    public void run() { 
     System.out.println("EXTENDS RUN>>"); 
    } 
} 

class ThreadExampleRunnable implements Runnable { 
    public void run() { 
     System.out.println("RUNNABLE RUN>>"); 
    } 
} 

class ThreadExampleMain{ 
    public static void main(String[] args) { 
     ThreadExample th1 = new ThreadExample(); 
     //th1.start(); 
     th1.run(); 

     ThreadExampleRunnable th2 = new ThreadExampleRunnable(); 
     th2.run(); 
    } 
} 

Answer 1

El método Thread.start() comienza un nuevo hilo, el punto de entrada para este hilo es el método run(). Si llama directamente a run(), se ejecutará en el mismo hilo. Dado que al llamar al Thread.start() se iniciará un nuevo hilo de ejecución, se puede llamar al método run() después (como en su ejemplo) el resto del método principal se ejecuta.

cambiar su método principal para llamar th1.start() y ejecutar repetidamente, se verá que a veces se da salida:

EXTENDS RUN>> 
RUNNABLE RUN >> 

ya veces se da salida:

RUNNABLE RUN >> 
EXTENDS RUN>> 

dependiendo de cómo java elige para programar su 2 hilos

Mira el java tutorial en esto.

Answer 2

Cuando llama al .run(), se llama al método y el código se ejecuta de la misma manera que cualquier otro método. Si llama al .start() en un hilo, sin embargo, el método run() se ejecutará en ese hilo, y no secuencialmente en el hilo principal.

Así que cuando se llama a th1.start(), que tienen código que se ejecuta en dos hilos a la vez: el hilo principal pasará a crear Th2 y luego llamar a su método run, mientras que el hilo Th1 llamará a su propio método run. No hay garantía en el orden de estos, porque se están ejecutando en paralelo.

Answer 3

Cuando llama al th1.run() está ejecutando el método run en el hilo actual, por lo que debe ocurrir antes de llamar al th2.run().

Cuando llama al th1.start(), se llama al método run en un nuevo hilo. En este caso, está sucediendo después de la llamada al th2.run(). (De hecho, teóricamente es posible que ocurra antes del th2.run() ... pero las implementaciones de Sun actuales y anteriores de thread.start() no provocan que el hilo actual "ceda" inmediatamente al nuevo hilo.)

Esto ilustra una error común con el uso de hilos de Java. Si desea ejecutar cosas en un nuevo hilo, debe llamar al thread.start(). Llamar directamente al thread.run() es casi siempre un error.

Answer 4

ejecutando run() es síncrono - ejecutar start() es asincrónico.

Las llamadas a run() son solo una llamada a método síncrono normal, y ocurren en ese orden. Utilizando th1.start(), se inicia un nuevo hilo, ahora es un rase de dos caballos; los dos métodos de ejecución ahora se están ejecutando de forma independiente; el primero gana, y no hay garantía de orden.

Pero si el pedido no está garantizado, ¿por qué el nuevo hilo se imprime más tarde la mayor parte del tiempo? En la práctica, lleva un tiempo iniciar un nuevo hilo, por lo que cuando se inicia, el otro método run() ya se ejecutó. Incluso en una máquina multinúcleo, donde ambos subprocesos se pueden ejecutar simultáneamente, el nuevo subproceso generalmente será el último, ya que el inicio del subproceso implica más trabajo.