Estoy confundido en join() método utilizado en los Hilos en Java. En el siguiente código:

//Using join() to wait for threads to finish.
class NewThread implements Runnable {
String name; //name of thread
Thread t;
NewThread(String threadname) {
name = threadname;
t = new Thread(this, name);
System.out.println("New thread: " + t);
t.start(); //Start the thread
}
//This is the entry point for thread.
public void run() {
try {
for (int i = 5; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println(name + " interrupted.");
}
System.out.println(name + " exiting.");
}
}
class DemoJoin {
public static void main(String args[]) {
NewThread ob1 = new NewThread("One");
NewThread ob2 = new NewThread("Two");
NewThread ob3 = new NewThread("Three");
System.out.println("Thread One is alive: "
+ ob1.t.isAlive());
System.out.println("Thread Two is alive: "
+ ob2.t.isAlive());
System.out.println("Thread Three is alive: "
+ ob3.t.isAlive());
//wait for threads to finish
try {
System.out.println("Waiting for threads to finish.");
ob1.t.join();
ob2.t.join();
ob3.t.join();
} catch (InterruptedException e) {
System.out.println("Main thread Interrupted");
}
System.out.println("Thread One is alive: "
+ ob1.t.isAlive());
System.out.println("Thread Two is alive: "
+ ob2.t.isAlive());
System.out.println("Thread Three is alive: "
+ ob3.t.isAlive());
System.out.println("Main thread exiting.");
}
}

Muestra de la salida de este programa es el que se muestra aquí:

New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
Thread One is alive: true
Thread Two is alive: true
Thread Three is alive: true
Waiting for threads to finish.
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Two: 2
Three: 2
One: 1
Two: 1
Three: 1
Two exiting.
Three exiting.
One exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
Main thread Exiting

En el código anterior :

  1. Yo no soy capaz de entender el flujo de ejecución del programa, Y cuando ob1 se crea entonces el constructor se llama donde t.start() está escrito, pero aún run() método no se ejecuta en lugar main() método continúa la ejecución. Entonces, ¿por qué está sucediendo esto?

  2. join() se utiliza el método de esperar hasta que el hilo en el que se llama no se termina, pero aquí en la salida vemos alternativo salidas del subproceso ¿por qué??

Y si el uso de join es esto entonces lo que es el uso de synchronized??

Sé que me falta un concepto básico aquí, pero no soy capaz de averiguar así que por favor ayuda.

  • «Yo no soy capaz de entender el flujo de ejecución del programa’ – OK, eso es normal con subprocesamiento múltiple. El truco es el diseño, así que no importa.
  • Debe ejecutar este programa en modo de depuración, entender mejor el concepto de join(). En realidad es difícil predecir el orden correcto. Para ejecutar en modo de depuración.
  • la llamada a start de constructor es una mala idea, el objeto no se han formado todavía.
  • Piense en ello como el bloqueo de la ejecución en paralelo. Cualquier declaraciones posteriores sólo se ejecutará después de la joined hilos son de hecho
InformationsquelleAutor user2696258 | 2013-08-28

12 Comentarios

  1. 159

    Usted debe entender , hilos de programación es controlada por el programador del subproceso.Así, no se puede garantizar el orden de ejecución de los subprocesos en circunstancias normales.

    Sin embargo, puede utilizar join() a esperar un hilo para completar su trabajo.

    Por ejemplo, en el caso

    ob1.t.join();

    Esta declaración no va a regresar hasta que el hilo t ha terminado de ejecutarse.

    Probar este,

    class Demo {
    Thread t = new Thread(
    new Runnable() {
    public void run () {
    //do something
    }
    }
    );
    Thread t1 = new Thread(
    new Runnable() {
    public void run () {
    //do something
    }
    }
    );
    t.start(); //Line 15
    t.join();  //Line 16
    t1.start();
    }

    En el ejemplo anterior, su tema principal es la ejecución. Cuando se encuentra en la línea 15, hilo t está disponible en el hilo de programador. Tan pronto como hilo principal llega a la línea 16, se espera para el hilo t para terminar.

    NOTA que t.join no hacer nada al hilo t o hilo t1. Sólo se ve afectado el hilo que se llama (es decir, la main() hilo).

    Editado:

    t.join(); debe estar dentro de la try bloque porque throws la InterruptedException excepción, de lo contrario obtendrá un error en tiempo de compilación. Por lo tanto, deben ser:

    try{
    t.join();
    }catch(InterruptedException e){
    //...
    }
    • He buscado en internet para una simple respuesta que te explique este concepto de una MANERA SENCILLA!! durante casi una hora. pero esta es la única respuesta que he encontrado que se fue directo al punto, de la manera más simple. @malwaregeek, Gracias.
    • gran explicación
    • demasiado buena explicación!
    • ¿Qué sucede si t.join() es eliminado(Línea 16) y t1.unirse es añadido después de la t1.start()?
    • Realmente útil respuesta
    • Gran explicación! 🙂
    • si los subprocesos de llamada entra en modo de suspensión será el subproceso actual ejecutar?
    • gracias….que respuesta me ayudó 🙂
    • se que el hilo principal se ejecuta de nuevo después de la t1 hilo va a wait estado. o se ejecutará sólo después de que el thread t1 completamente ejecutado
    • Lo que no entiendo es ¿cuál es el subproceso actual, cuando hay dos subprocesos de ejecución? Desde line 15 tiene tanto t ymain ejecución. Cuando dices join() en line 16, el subproceso actual debe ser parado, pero fue t que comenzó el pasado. Y ¿qué pasa cuando tienes 3 subprocesos que se ejecutan después de line 17? Cuál es la actual?
    • Confundido acerca de que si t1.start() desde t1 se comenzó a utilizar main hilo no debería comenzar a menos que t hilo es sobre ya que estamos utilizando t.join.
    • He editado esta respuesta para eliminar las palabras «subproceso actual.» Cada vez que usted vea esas palabras en la documentación, que son no hablando sobre la que se ejecuta actualmente hilo!! (El hilo que tendría que estar en un programa que tiene muchos hilos que se ejecutan en un multi-núcleo de la máquina?) «Subproceso actual» realmente significa «el hilo que está llamando a la función». Thread.currentThread() devuelve una referencia a la Thread objeto de que los controles de la persona que llama. Thread.sleep(n) es sólo una función que espera n milisegundos antes de regresar, t.join() es sólo una función que espera que el hilo t a morir, etc.
    • la última nota se explica todo!
    • ¿qué sucede si utilizo t.join() después de t1.start()?
    • La última nota es una gran explicación. Gracias!

  2. 5

    Primero de todo, cuando usted cree ob1, a continuación, constructor es llamado y se inicia la ejecución. En ese momento t.start() también se ejecuta en un hilo separado. Recuerde que cuando se crea un nuevo hilo, se ejecuta puestas paralelamente al hilo principal. Y es por eso que la principal iniciar la ejecución de nuevo con la siguiente instrucción.

    Y Join() declaración se utiliza para evitar que el niño hilo de convertirse en huérfanos. Significa que si usted me cansaría de llamada join() en la clase principal, a continuación, hilo principal de salida después de su ejecución y el niño hilo será todavía no la ejecución de las instrucciones. Join() va a esperar hasta que todos los niños hilo de completar su ejecución y, a continuación, sólo el principal método de salida.

    Ir a través de este artículo, es de gran ayuda.

    • Así que esto significa que, si no hay ninguna combinación (), a continuación, «Uno, Dos, Tres…» la salida de la parte no vienen ??
    • no..no es eso. Su muestra la salida de la Ont, dos, tres.. pero en medio de una, dos, tres..Main Thread Existing se muestra porque el hilo principal finaliza su ejecución y no tiene nada que ver con el hilo hijo.
  3. 3

    Yo no soy capaz de entender el flujo de ejecución del programa, Y cuando ob1 es creado, entonces el constructor se llama donde t.start() está escrito, pero aún run() método no se ejecuta en lugar método main() continúa la ejecución. Entonces, ¿por qué está sucediendo esto?

    Esto depende de Hilo Programador como principal comparte el mismo orden de prioridad. La llamada a start() no significa ejecutar() será llamado inmediatamente, depende de hilo programador cuando se opta por ejecutar el subproceso.

    método join() se utiliza para esperar hasta que el hilo en el que se llama no se termina, pero aquí en la salida vemos alternativo salidas del subproceso ¿por qué??

    Esto es porque el Hilo.sleep(1000) en el código. Quitar esa línea y usted verá ob1 termina antes de que ob2 que a su vez termina antes de que ob3 (como era de esperar con join()). Después de haber dicho que todo depende de cuando ob1 ob2 y ob3 comenzó. Llamar a dormir pausa hilo de ejecución para >= 1 segundo (en el código), dando programador de una oportunidad para llamar a otros subprocesos en espera (con la misma prioridad).

  4. 1

    Primera regla de roscado – «Threading es divertido»…

    Yo no soy capaz de entender el flujo de ejecución del programa, Y
    cuando ob1 es creado, entonces el constructor se llama donde t.start() es
    escrito pero todavía run() método no se ejecuta en lugar main() método
    continúa la ejecución. Entonces, ¿por qué está sucediendo esto?

    Esto es exactamente lo que debe suceder. Cuando llame Thread#start, el tema es creado y cronograma de ejecución, puede ocurrir inmediatamente (o lo suficientemente cerca de ella), puede que no. Esto viene al hilo de programador.

    Esto se reduce a que el hilo de ejecución está programada y de lo que está pasando en el sistema. Normalmente, cada subproceso se dará una pequeña cantidad de tiempo para ejecutar antes de que se ponga de nuevo a «dormir» y otro hilo es permitido ejecutar (obviamente en múltiples procesador de ambientes, más que un hilo puede estar en ejecución en el tiempo, pero vamos a intentar mantenerlo simple ;))

    Subprocesos también puede yield ejecución, permitir que otros hilos en el sistema para tener la oportunidad de ejecutar.

    Usted podría tratar de

    NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("New thread: " + t);
    t.start(); //Start the thread
    //Yield here
    Thread.yield();
    }

    Y se podría hacer una diferencia en la forma en que los hilos de ejecución…igualmente, podría sleep por un pequeño periodo de tiempo, pero esto podría provocar que el hilo se debe pasar por alto para su ejecución por un periodo de ciclos (a veces desea que esta, a veces no)…

    join() se utiliza el método de esperar hasta que el hilo en el que se llama
    no se termina, pero aquí en la salida vemos alternativo salidas de
    el hilo de eso??

    La forma en que usted haya declarado la pregunta está mal…join esperará a que el Thread es llamado a morir antes de regresar. Por ejemplo, si en función del resultado de un Thread, usted podría utilizar join saber cuando el Thread ha terminado antes de intentar recuperar esto es el resultado.

    Igualmente, no se pudo sondear el hilo, pero este va a comer los ciclos de CPU que podrían ser mejor utilizados por el Thread lugar…

    • ¿qué entendemos por sondear el hilo??
    • Básicamente. Se requeriría de un bucle, que periódicamente revise para ver si el hilo había competido o no. Puede que haría uso de la producción o de sueño. Pero esto requeriría que el hilo tiene tiempo para ejecutar, tomar tiempo lejos de otros hilos
  5. 1

    La JVM y el sistema operativo subyacente, tienen una considerable libertad a la hora de programar las cosas. El hecho de que usted obtenga todo el camino a «la Espera de los hilos para terminar» antes de ver la salida de los hilos individuales puede significar simplemente que el hilo de inicio tarda un poco más (es decir, se necesita algo de tiempo entre el momento en que un hilo se convierte en «vivo» y cuando el run() método realmente comienza a ejecutar). Usted podría ver el hilo de salida cuanto antes, pero no se garantiza de ninguna forma.

    Como para join(), sólo garantiza que todo lo que está después de esto sólo ocurrirá una vez que el hilo se están uniendo a que se hace. Así que cuando usted tiene tres join() llamadas en una fila, esto no significa que los hilos deben terminar en un orden determinado. Simplemente significa que usted va a esperar para ob1 primera. Una vez ob1 acabados, ob2 y ob3 todavía puede estar en ejecución o ya terminado. Si terminado, el otro join() llamadas volverá inmediatamente.

    sincronizado se utiliza específicamente cuando varios subprocesos acceder al mismo objeto y realizar cambios en él. Un bloque sincronizado está garantizado nunca a ser ejecutado por dos hilos simultáneamente – es decir, el hilo que lo ejecuta tiene el objeto sincronizado para sí.

  6. 1

    cuando ob1 es creado, entonces el constructor se llama donde «t.start()» está escrito pero todavía run() método no se ejecuta en lugar método main() se ejecuta más. Entonces, ¿por qué está sucediendo esto?

    aquí los hilos y el hilo principal tiene la misma prioridad.La ejecución de la igualdad de subproceso de prioridad depende totalmente de la Thread schedular.Usted no puede esperar que ejecutar en primer lugar.

    método join() se utiliza para esperar hasta que el hilo en el que se llama no se termina, pero aquí en la salida vemos alternativo salidas del subproceso ¿por qué??

    Aquí su llamamiento a continuación las declaraciones del hilo principal.

         ob1.t.join();
    ob2.t.join();
    ob3.t.join();

    Así hilo principal espera para ob1.t,ob2.t,ob3.t hilos para morir(mira en Subproceso#unirse a doc).Así que las tres hilos se ejecuta correctamente y el hilo principal se completa después de que

  7. 1

    Mis Comentarios:

    Cuando veo la salida, la salida se mezcla con Uno, Dos, Tres, que son el hilo conductor de nombres y que se ejecutan simultáneamente. No estoy seguro de que cuando usted dice que el hilo no se está ejecutando por el método principal.

    No estoy seguro si he entendido tu pregunta o no. Pero yo estoy poniendo mi respuesta de lo que yo podía entender, espero que le puede ayudar.

    1) a Continuación, se crea el objeto, se llama al constructor, en la construcción se ha de iniciar el método, que inició el hilo y ejecutado el contenido escrito dentro de run() método.

    Así como se han creado 3 objetos (3 hilos – uno, dos, tres), todos de 3 hilos comenzó a ejecutar de forma simultánea.

    2) de combinación y Sincronización
    Son 2 cosas diferentes, la Sincronización es cuando hay varios hilos comparten un recurso común y un hilo debería utilizar ese recurso en un momento. E. g. Hilos como DepositThread, WithdrawThread etc. comparten un objeto común como BankObject. Así, mientras que DepositThread se está ejecutando, el WithdrawThread va a esperar si son sincronizados. wait(), notify(), notifyAll() se utilizan para la comunicación inter-thread. Plz de google para saber más.

    sobre Join(), es cuando varios subprocesos se están ejecutando, pero en las que participe. por ejemplo, si hay dos subproceso de t1 y t2 y en multi-hilo env corren, la salida sería:
    t1-0
    t2-0
    t1-1
    t2-1
    t1-2
    t2-2

    y utilizamos t1.join(), sería:
    t1-0
    t1-1
    t1-2
    t2-0
    t2-1
    t2-2

    Este se utiliza en tiempo real, cuando a veces no mezclar el hilo en ciertas condiciones y una depende de la otra para ser completado (no en el recurso compartido), por lo que se puede llamar el método join ().

    • Ok, Pero cuando t.start() se encuentran durante el constructor de ejecución (run) método no se ejecuta en lugar del hilo principal se ejecuta…¿por qué sucede esto??
    • Me puedes explicar qué quieres decir exactamente con hilo principal? ¿Por qué crees run() método no se ejecuta?
    • Me refiero a la función main() que es el subproceso actual, y no digo que el método de ejecución no se ejecuta en absoluto me refiero a por qué no se ejecuta cuando t.start() es encontrado… bueno, supongo que tengo sus respuestas en el siguiente post!
    • OK. Eso es genial
  8. 1

    Hilo programador es el responsable de la programación de subprocesos. Así que cada vez que ejecute el programa, no hay ninguna garantía de que el orden de ejecución de subprocesos.
    Supongamos que tenemos un objeto de subproceso denominado threadOne y si join() se llama en threadOne como este:

    threadOne.join()

    a continuación, todos en la actualidad la ejecución de subprocesos se pondrá en pausa hasta thread1 ha terminado su ejecución o se cancela.

    Considere el siguiente fragmento de código:

    class RunnableSample implements Runnable {
    private Thread t;
    private String threadName;
    public RunnableSample(String name) {
    this.threadName = name;
    }
    public void run() {
    try {
    for(int i = 4; i >= 1; i--) {
    System.out.println(Thread.currentThread().getName() + ", " + i);
    Thread.sleep(500);
    }
    } catch (InterruptedException e) {
    System.out.println(threadName + " interrupted");
    }
    }
    public void start() {
    if(t == null)
    t = new Thread(this, threadName);
    t.start();
    try {
    t.join();
    } catch(Exception e) {
    System.out.println(e);
    }
    }
    }
    public class RunnableDemo {
    public static void main(String[] args) {
    RunnableSample r1 = new RunnableSample("threadOne");
    r1.start();
    RunnableSample r2 = new RunnableSample("threadTwo");
    r2.start();
    RunnableSample r3 = new RunnableSample("threadThree");
    r3.start();
    }
    }

    La salida del programa anterior será:

    threadOne, 4
    threadOne, 3
    threadOne, 2
    threadOne, 1
    threadTwo, 4
    threadTwo, 3
    threadTwo, 2
    threadTwo, 1
    threadThree, 4
    threadThree, 3
    threadThree, 2
    threadThree, 1

    Desde join() se llama en threadOne en primer lugar, threadTwo y threadThree estará en pausa hasta que threadOne termina. (Tenga en cuenta que threadOne, threadTwo y ThreadThree todos han comenzado). Ahora los hilos se ejecutan en un orden específico.
    Si join() no se llama en un hilo en nuestro ejemplo, entonces no habrá ninguna orden de ejecución de subprocesos.

    public void start() {
    if(t == null)
    t = new Thread(this, threadName);
    t.start();
    }

    Su salida será:

    threadOne, 4
    threadThree, 4
    threadTwo, 4
    threadTwo, 3
    threadThree, 3
    threadOne, 3
    threadOne, 2
    threadThree, 2
    threadTwo, 2
    threadOne, 1
    threadThree, 1
    threadTwo, 1

    Llegando a la sincronización, que es útil si desea controlar el acceso de múltiples hilos en cualquier recurso compartido. Si desea restringir sólo un hilo para acceder a los recursos compartidos de sincronización es la mejor manera de hacerlo.

  9. 1

    No hay palabras que sólo se ejecuta el código

    //Thread class
    public class MyThread extends Thread {
    String result = null;
    public MyThread(String name) {
    super(name);
    }
    public void run() {
    for (int i = 0; i < 1000; i++) {
    System.out.println("Hello from " + this.getName());
    }
    result = "Bye from " + this.getName();
    }
    }

    La Clase Principal De La

    public class JoinRND {
    public static void main(String[] args) {
    System.out.println("Show time");
    //Creating threads
    MyThread m1 = new MyThread("Thread M1");
    MyThread m2 = new MyThread("Thread M2");
    MyThread m3 = new MyThread("Thread M3");
    //Starting out Threads
    m1.start();
    m2.start();
    m3.start();
    //Just checking current value of thread class variable
    System.out.println("M1 before: " + m1.result);
    System.out.println("M2 before: " + m2.result);
    System.out.println("M3 before: " + m3.result);
    //After starting all threads main is performing its own logic in
    //parallel to other threads
    for (int i = 0; i < 1000; i++) {
    System.out.println("Hello from Main");
    }
    try {
    System.out
    .println("Main is waiting for other threads to get there task completed");
    m1.join();
    m2.join();
    m3.join();
    } catch (InterruptedException e) {
    //TODO Auto-generated catch block
    e.printStackTrace();
    }
    System.out.println("M1 after" + m1.result);
    System.out.println("M2 after" + m2.result);
    System.out.println("M3 after" + m3.result);
    System.out.println("Show over");
    }
    }
  10. 1

    Me llegó a través de la combinación (), mientras que el aprendizaje acerca de la condición de carrera y voy a despejar las dudas que tenía. Así que vamos a tomar este pequeño ejemplo

    Thread t2 = new Thread(
    new Runnable() {
    public void run () {
    //do something
    }
    }
    );
    Thread t1 = new Thread(
    new Runnable() {
    public void run () {
    //do something
    }
    }
    );
    t2.start(); //Line 11
    t1.start(); //Line 12
    t2.join();  //Line 13
    t1.join();  //Line 14
    System.out.print("<Want to print something that was being modified by t2 and t1>")

    Mi OBJETIVO


    Tres subprocesos que se ejecutan a saber: t1, t2 y el hilo principal. Quiero imprimir algo después de la t1 y la t2 ha terminado. La operación de impresión está en mi hilo principal, por tanto, de la respuesta que necesito para que t1 y t2 en finalizar y, a continuación, imprimir el resultado.

    Por lo tanto, t1.join() sólo hace que el hilo principal de espera, hasta la t1 hilo completa antes de ir a la línea siguiente en el programa.

    Aquí es la definición como por GeeksforGeeks:

    java.lang.El hilo de la clase proporciona el método join (), que permite a una
    el hilo que esperar hasta que otro hilo finaliza su ejecución.

    Aquí es una cuestión que se pueda resolver tu duda

    Q-> Le t1 hilo obtener el intervalo de tiempo para que las ejecute el hilo programador, cuando el programa está en el procesamiento de la t2.join() en Línea
    13
    ?

    ANS-> Sí lo serán elegibles para obtener el intervalo de tiempo para que se ejecute como ya hemos hecho es elegible mediante la ejecución de la línea t1.inicio() en Línea
    11
    .
    t2.join() sólo se aplica la condición cuando la JVM se vaya
    a la siguiente línea, que es la Línea 14.
    Es posible que sean t1
    puede obtener terminado de procesar en Línea 13.

  11. 0

    join() es un método de instancia de java.lang.Clase Thread que podemos utilizar el método join() para asegurar que todos los hilos que se inició a partir principal debe terminar en el orden en el que se inician y también a las principales debe finalizar en el último. En otras palabras, se espera para este hilo para morir.

    Excepción:
    método join() throws InterruptedException.

    Estado de subproceso:
    Cuando el método join() es llamado en el hilo va de que se ejecute al estado de espera. Y espere a que el hilo a morir.

    sincronizado bloque:
    Hilo necesidad de no adquirir objetos de bloqueo antes de llamar al método join() es decir, método join() se puede llamar desde fuera sincronizado bloque.

    Tiempo de espera:
    join():
    Espera a que este hilo para morir.

    public final void join() throws InterruptedException;

    Este método llama internamente a la combinación(0). Y el tiempo de espera de 0 significa esperar para siempre;

    unirse(long millis) – método sincronizado
    De espera en la mayoría de los millis milisegundos para este hilo para morir. Un tiempo de espera de 0 significa que a esperar para siempre.

    public final synchronized void join(long millis)
    throws InterruptedException;
    public final synchronized void join(long millis, int nanos)
    throws InterruptedException;

    Ejemplo de método de combinación

    class MyThread implements Runnable {
    public void run() {
    String threadName = Thread.currentThread().getName();
    Printer.print("run() method of "+threadName);
    for(int i=0;i<4;i++){
    Printer.print("i="+i+" ,Thread="+threadName);
    }         
    }
    }
    public class TestJoin {
    public static void main(String...args) throws InterruptedException {
    Printer.print("start main()...");
    MyThread runnable = new MyThread();
    Thread thread1=new Thread(runnable);
    Thread thread2=new Thread(runnable);
    thread1.start();
    thread1.join();
    thread2.start();
    thread2.join();
    Printer.print("end main()");
    }
    }
    class Printer {
    public static void print(String str) {
    System.out.println(str);
    }
    }
    Output:
    start main()...
    run() method of Thread-0
    i=0 ,Thread=Thread-0
    i=1 ,Thread=Thread-0
    i=2 ,Thread=Thread-0
    i=3 ,Thread=Thread-0
    run() method of Thread-1
    i=0 ,Thread=Thread-1
    i=1 ,Thread=Thread-1
    i=2 ,Thread=Thread-1
    i=3 ,Thread=Thread-1
    end main()

    Nota:
    llamar thread1.join() de hecho el hilo principal para esperar hasta que el Hilo-1 muere.

    Vamos a ver un programa para el uso de la combinación(long millis)

    Primera, join(1000) será llamado en el Hilo-1, pero una vez que 1000 millisec están arriba, hilo principal se puede reanudar y empezar a thread2 (hilo principal no tendrá que esperar para el Hilo-1 a morir).

    class MyThread implements Runnable {
    public void run() {
    String threadName = Thread.currentThread().getName();
    Printer.print("run() method of "+threadName);
    for(int i=0;i<4;i++){
    try {
    Thread.sleep(500);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    Printer.print("i="+i+" ,Thread="+threadName);
    }         
    }
    }
    public class TestJoin {
    public static void main(String...args) throws InterruptedException {
    Printer.print("start main()...");
    MyThread runnable = new MyThread();
    Thread thread1=new Thread(runnable);
    Thread thread2=new Thread(runnable);
    thread1.start();
    //once 1000 millisec are up,
    //main thread can resume and start thread2.
    thread1.join(1000);
    thread2.start();
    thread2.join();
    Printer.print("end main()");
    }
    }
    class Printer {
    public static void print(String str) {
    System.out.println(str);
    }
    }
    Output:
    start main()...
    run() method of Thread-0
    i=0 ,Thread=Thread-0
    run() method of Thread-1
    i=1 ,Thread=Thread-0
    i=2 ,Thread=Thread-0
    i=0 ,Thread=Thread-1
    i=1 ,Thread=Thread-1
    i=3 ,Thread=Thread-0
    i=2 ,Thread=Thread-1
    i=3 ,Thread=Thread-1
    end main()

    Para obtener más información, consulte mi blog:

    http://javaexplorer03.blogspot.in/2016/05/join-method-in-java.html

  12. 0

    Ver el concepto es muy simple.

    1) Todos los hilos se inician en el constructor y, por lo tanto, listo para correr estado. Principal es ya el subproceso en ejecución.

    2) Ahora se llama la t1.join(). Aquí lo que pasa es que el hilo principal se presenta anudado detrás de la t1 hilo. Así que usted puede imaginar ya un hilo con los principales unido al extremo inferior de la t1.

    3) Ahora hay tres hilos que se podrían ejecutar: t2, t3 y el hilo combinado(t1 + principal).

    4)Ahora ya hasta t1 está terminado principal no se pueden ejecutar. para la ejecución de las otras dos instrucciones join ha sido detenido.

    5) por Lo que el programador decide ahora que de las mencionadas anteriormente(en el punto 3) hilos de ejecución que explica la salida.

Dejar respuesta

Please enter your comment!
Please enter your name here